CreativePython 1.1.6__py3-none-any.whl → 1.2__py3-none-any.whl

CreativePython/GuiRenderer.py

@@ -997,8 +997,6 @@ class DisplayMirror:
          else:
             item.qObject.setZValue(qZValue)
             self._scene.addItem(item.qObject)      # attach QGraphicsItem to scene
-            cacheMode = QtWidgets.QGraphicsItem.CacheMode.DeviceCoordinateCache
-            item.qObject.setCacheMode(cacheMode)
 
          posArgs = {}
          if x is not None:
@@ -2874,9 +2872,6 @@ class GroupMirror(_DrawableMirror):
       item.qObject.setZValue(qZValue)
       self.qObject.addToGroup(item.qObject)
 
-      cacheMode = QtWidgets.QGraphicsItem.CacheMode.DeviceCoordinateCache
-      item.qObject.setCacheMode(cacheMode)
-
    def _removeChild(self, args, responseId):
       """Removes a child from the group."""
       itemId = args.get('itemId')

CreativePython/RealtimeAudioPlayer.py

@@ -306,9 +306,9 @@ class _RealtimeAudioPlayer:
       self.loopRegionStartFrame = max(0.0, float(loopRegionStartFrame))
       self.loopRegionEndFrame = float(loopRegionEndFrame) if loopRegionEndFrame is not None else -1.0
 
-      # adjust the loop region end frame so it does not exceed the last valid frame in the audio file
+      # adjust the loop region end frame so it does not exceed the end of the audio file
       if self.loopRegionEndFrame > 0:
-         self.loopRegionEndFrame = min(self.loopRegionEndFrame, self.numFrames - 1 if self.numFrames > 0 else 0.0)
+         self.loopRegionEndFrame = min(self.loopRegionEndFrame, float(self.numFrames))
 
       # ensure the loop region is valid: if the start frame is after or equal to the end frame, reset to default (full file)
       if self.numFrames > 0 and self.loopRegionEndFrame > 0 and self.loopRegionStartFrame >= self.loopRegionEndFrame:
@@ -689,7 +689,8 @@ class _RealtimeAudioPlayer:
 
       # determine where playback should end for this segment
       # NOTE: supports three modes: natural EOF, loop region end, or play(size) duration
-      effectiveSegmentEndFrame = numAudioFrames - 1
+      # effectiveSegmentEndFrame is the exclusive end (first frame NOT to play)
+      effectiveSegmentEndFrame = float(numAudioFrames)
       if looping and self.loopRegionEndFrame > 0:
          effectiveSegmentEndFrame = self.loopRegionEndFrame
       elif not looping and self.targetEndSourceFrame > 0:
@@ -699,14 +700,13 @@ class _RealtimeAudioPlayer:
       # NOTE: batch boundary detection avoids per-sample checks (major optimization)
       framesToProcess = frames
       willHitBoundary = False
-      boundaryFrame = -1
 
       if effectiveSegmentEndFrame > 0:
          framesToEndpoint = (effectiveSegmentEndFrame - self.playbackPosition) / rateFactor
-         if framesToEndpoint < frames and framesToEndpoint > 0:
+         if 0 <= framesToEndpoint < frames:
             willHitBoundary = True
-            boundaryFrame = int(np.floor(framesToEndpoint))
-            framesToProcess = min(frames, boundaryFrame + 1)
+            # ceil gives the number of frames that stay strictly within the endpoint
+            framesToProcess = min(frames, int(np.ceil(framesToEndpoint)))
 
       ###########################################################################
       # PHASE 2: PITCH SHIFTING VIA TIME-STRETCH INTERPOLATION
@@ -856,7 +856,8 @@ class _RealtimeAudioPlayer:
                outdata[framesToProcess:, :] = 0.0
 
       # safety - fill any unfilled portion with silence
-      if framesToProcess < frames and self.isPlaying:
+      # skip when willHitBoundary is True: boundary handling already filled remainder (via recursion or explicit zero-fill)
+      if framesToProcess < frames and self.isPlaying and not willHitBoundary:
          outdata[framesToProcess:, :] = 0.0
 
       # update pan smoothing (prevents clicks from abrupt pan changes)

animation.py

@@ -0,0 +1,554 @@
+#######################################################################################
+# animation.py       Version 1.0     18-Apr-2026     Bill Manaris and Taj Ballinger
+#######################################################################################
+
+
+# The animation library provides a simplified way to automate repeated calling of functions
+# for animation or other automation effects. Examples may range from continuously animating 
+# GUI graphics (similar to MIT Processing's draw() loop), to sequencing precise, data-driven 
+# musical automation (such as volume envelopes or filter sweeps). 
+#
+# It uses a single "master" timer, which makes sure that all visual, audio, and other effects
+# are perfectly synchronized (unlike creating individual timers for each). This is very important.
+#
+# It provides an Animate static class that can register functions to call repeatedly to support various scenarios. 
+# Anything more involved can be created using regular timers (via the timer library).
+#
+# Additionally, it provides a few shorthand functions, like animate(), setAnimationRate(), etc.
+#
+# NOTE:  Animation engine is initialized (i.e., master timer starts ticking) at module load time!!!
+#        This doesn't cost much, and simplifies life...
+
+class Animate:
+   """
+   Animate provides methods to automate calling of user-provided functions using a common, lock-step
+   time interval (or framerate).
+   """
+   _ENGINE     = None             # master timer, created and started at module load time
+   _interval   = 1000.0 / 60.0    # current timer interval (in ms)
+   _actionList = []               # list of registered callback functions to automate
+
+
+   @staticmethod
+   def _init():
+      """
+      Initialize and start master animation timer.
+      """
+
+      # initialize only if engine has not been created previously
+      if Animate._ENGINE is None:   # no engine available? 
+
+         # yes, so create a new engine and start it
+         from timer import Timer
+
+         # use a regular timer (i.e., our master timer) to call every interval
+         # our tick function (which in turns calls all registered functions appropriately)
+         # Timer(delay, callback, arguments, repeat)
+         Animate._ENGINE = Timer(Animate._interval, Animate._tick, [], True)   # create it
+         Animate._ENGINE.start()                                               # and start it!!!
+
+      # now, the master timer is running, ready to call any function that gets registered
+
+
+   @staticmethod
+   def _tick():
+      """
+      Call each registered callback function once.
+      """
+      # iterate through the list of registered actions
+      for action in Animate._actionList:
+
+         if callable(action):   # is this a function?
+
+            # yes, so execute it!!
+            action()
+
+      # now, all registered functions have been called one time
+
+
+   @staticmethod
+   def resume():
+      """
+      Resume the animation.
+      """
+
+      if Animate._ENGINE is not None:   # do we have an engine?
+
+         # yes, so resume it (starting it continues where we left off...)
+         Animate._ENGINE.start()
+
+
+   @staticmethod
+   def pause():
+      """
+      Pause the animation.
+      """
+
+      if Animate._ENGINE is not None:   # do we have an engine?
+
+         # yes, so pause it (stopping simply stops ticking - everything else remains in place!!)
+         Animate._ENGINE.stop()
+
+
+   @staticmethod
+   def add(action):
+      """
+      Register action (a callback function) to automate calling it.
+      A function may be registered several times (hopefully with different parameters).
+      """
+
+      if callable(action):   # is this a function?
+         
+         # yes, so add it to list of functions to be called
+         Animate._actionList.append(action)
+
+      else:
+
+         # let them know that something is wrong...
+         print(f"Animate.add(): '{action}' is not a callable function.")
+
+
+   @staticmethod
+   def addWithValues(action, values, duration=None, repeat=1, whenDone=None):
+      """
+      Register 'action' (a callback function) to be called repeatedly, passing it a sequence 
+      of 'values' over a specified 'duration'.  This will be repeated 'repeat' times.
+      When this process is finished, function 'whenDone' is called (if provided).
+      """
+
+      if not callable(action):   # is it NOT a function?
+
+         # let them know something is wrong...
+         print(f"Animate.addWithValues(): '{action}' is not a callable function.")
+
+      elif len(values) == 0:     # is the list empty?
+
+         # let them know something is wrong...
+         print("Animate.addWithValues(): 'values' list is empty.")
+
+      else:   # value list is not empty, so...
+
+         if duration is None:   # default duration?
+
+            timeDelayBetweenValues = Animate._interval   # use engine's default interval
+
+         else:   # they have provided their own time-stretching, so...
+
+            # calculate time delay (in millisecs) between values
+            timeDelayBetweenValues = (duration * 1000.0) / len(values)
+
+         # now, timeDelayBetweenValues contains how long we should wait to process next value... 
+
+         # check if this makes sense...
+         if timeDelayBetweenValues < Animate._interval:   # is duration provided too small for our frame rate?
+            
+            # calculate the minimum possible duration for the error message
+            minAllowableDuration = (Animate._interval * len(values)) / 1000.0
+            
+            # let them know something is wrong...
+            print(f"Animate.addWithValues(): duration ({duration}s) is too short to process, given frame rate ({Animate.getRate()})")
+            print(f"                         Should be at least {minAllowableDuration:.2f} secs.")
+
+         else:   # all good, so proceed...
+
+            import time
+
+            #####
+            # Now, we will build a closure (inner function) to handle processing each individual value, 
+            # as well as anything else that may need to happen (i.e., start over for the next repetition,
+            # or call the 'whenDone' function if we are completely done - after the last value).
+
+            # A closure needs some non-local (i.e., external to it) variables to remember how far it has gone.
+
+            # NOTE:  Every time addWithValues() above gets called, new variables are created here, 
+            #        and these are combined with the closure below, maintaining its state persistently
+            #        without overwriting each other - it works well.
+
+            # external variables to be wrapped within the closure
+            valuesIndex   = 0   # points to next value to be processed
+            repeatCounter = 0   # how many repetitions done so far
+
+            # timer delay (in millisecs) for each value
+            delay = timeDelayBetweenValues
+            
+            # remembers when the previous execution happened
+            previousTime = time.time() * 1000.0   # initialize to "now"...
+
+            # define an inner function (closure) that contains the logic of what to do 
+            # with each provided value... 
+            def processEachValueClosure():
+
+               nonlocal previousTime    # remembers when previous execution happened
+               nonlocal valuesIndex     # remembers which value is to be processed this time
+               nonlocal repeatCounter   # remembers how many times we have processed the complete value list
+
+               # get current time (in millisecs)
+               currentTime = time.time() * 1000.0
+               
+               # has enough time passed to trigger the next value?
+               if (currentTime - previousTime) >= delay:
+                  
+                  # yes, update time tracker
+                  previousTime = previousTime + delay
+                  
+                  # act only if there are remaining values to be processed
+                  if valuesIndex < len(values):   # any left?
+                     
+                     # yes, so...
+                     
+                     # get next value
+                     value = values[valuesIndex]
+                     
+                     # NOTE: this is the important step that advances the animation!!!
+                     action(value)   # execute the original callback with the current value 
+                     
+                     # point to next value to be processed (if any)
+                     valuesIndex = valuesIndex + 1
+
+                  # now, the current value has been processed...
+                     
+                  # have we completed processing all the values?
+                  if valuesIndex >= len(values):   # no more values left?
+                     
+                     # yes, we are done... so, advance to the next repetition (if any)
+                     repeatCounter = repeatCounter + 1
+
+                     # do we have more repetitions?
+                     if repeat == -1 or repeatCounter < repeat:   
+                        
+                        # yes, so start processing values once more
+                        valuesIndex = 0   # point to first value
+
+                     else:   # we are done repeating, so...
+
+                        # remove this inner function from the engine...
+                        Animate.remove( processEachValueClosure )
+                        
+                        # and execute the callback (if any)
+                        if callable(whenDone):   # is there a completion callback?
+                           
+                           # yes, so execute it!!
+                           whenDone()
+
+               # now, we have finished processing current value, and have taken care
+               # of anything else that may have needed to happen (i.e., start over next repetition,
+               # or called 'whenDone' function, if we are completely done - after this value) 
+
+            # NOTE:  Very important - now that this inner function has been built, 
+            #        we need to register it with our engine, so it can do its job...
+
+            # register the closure to be called - it will take care of everything else...
+            Animate._actionList.append(processEachValueClosure)
+
+
+   @staticmethod
+   def addWithTimedValues(action, values, times, duration=None, repeat=1, whenDone=None):
+      """
+      Register 'action' (a callback function) to be called repeatedly. 
+      'values' is a list of sublists containing the parameters to be passed to the action.
+      'times' is a parallel list containing the target timestamps (in millisecs) for each value.
+      This will be repeated 'repeat' times.
+      When this process is finished, function 'whenDone' is called (if provided).
+      """
+
+      if not callable(action):   # is it NOT a function?
+
+         # let them know that something is wrong...
+         print(f"Animate.addWithTimedValues(): '{action}' is not a callable function.")
+
+      elif len(values) == 0:     # is the list empty?
+
+         # let them know that something is wrong...
+         print("Animate.addWithTimedValues(): 'values' list is empty.")
+
+      elif len(values) != len(times):   # are the lists not parallel?
+
+         # let them know that something is wrong...
+         print(f"Animate.addWithTimedValues(): length of 'values' ({len(values)}) and 'times' ({len(times)}) must be the same.")
+
+      else:   # lists are non-empty and parallel, so...
+
+         # calculate all raw intervals between consecutive times
+         # (if list has only 1 item, intervals will be empty)
+         intervals = [times[i] - times[i-1] for i in range(1, len(times))]
+
+         # check for simultaneous or out-of-order timestamps
+         if len(intervals) > 0 and min(intervals) <= 0:
+
+            # let them know that something is wrong...
+            print(f"Animate.addWithTimedValues(): all timestamps should be larger than their previous one.")
+
+         else:   # timestamps are valid and strictly increasing, so check engine limits...
+
+            # initialize default time scale (no time-stretching)
+            timeScale = 1.0
+
+            if duration is not None:   # did they provide duration?
+
+               # find the original duration (very last element in the times sequence)
+               originalDuration = float(times[-1])
+
+               if originalDuration > 0:
+
+                  # calculate scale factor to stretch/compress the overall timing
+                  timeScale = (duration * 1000.0) / originalDuration
+
+            # adjust the smallest raw interval by our timeScale to see what the engine will actually process
+            isTooSmall = False
+            
+            if len(intervals) > 0:
+               
+               minInterval = min(intervals) * timeScale
+               
+               if minInterval < Animate._interval:   # is the smallest gap too tight?
+                  
+                  isTooSmall = True   # remember that
+
+            # now, either isTooSmall is True, meaning the tightest gap is invalid, or
+            # it is False, meaning all intervals are valid 
+
+            if isTooSmall:   # did we find an interval that is too small?
+               
+               # calculate what the scale factor WOULD need to be to make the smallest gap fit the engine
+               # (we can safely divide by min(intervals) here because we proved > 0 in the previous block)
+               requiredScaleFactor = Animate._interval / float(min(intervals))
+               
+               # calculate the minimum allowable duration (in seconds) based on that scale factor
+               originalDuration = float(times[-1])
+               minAllowableDuration = (requiredScaleFactor * originalDuration) / 1000.0
+               
+               if duration is not None:   # did they provide a duration?
+                  
+                  # let them know their duration is too short
+                  print(f"Animate.addWithTimedValues(): duration ({duration} secs) is too small to process, given frame rate ({Animate.getRate()}).")
+                  print(f"                              Should be at least {minAllowableDuration:.2f} secs.")
+                  
+               else:   # they didn't provide a duration, but the raw timestamps are too tight
+                  
+                  # let them know they need to stretch the sequence
+                  print(f"Animate.addWithTimedValues(): found time interval that is too small ({minInterval} secs), given frame rate ({Animate.getRate()}).")
+                  print(f"                              Increase interval between times, or provide a duration of at least {minAllowableDuration:.2f} secs.")
+            
+            else:   # all good, so proceed...
+
+               import time
+
+               #####
+               # Now, we will build a closure (inner function) to handle processing each individual value, 
+               # as well as anything else that may need to happen (i.e., start over for the next repetition,
+               # or call the 'whenDone' function if we are completely done - after the last value).
+
+               # A closure needs some non-local (i.e., external to it) variables to remember how far it has gone.
+
+               # NOTE:  Every time addWithTimedValues() above gets called, new variables are created here, 
+               #        and these are combined with the closure below, maintaining its state persistently
+               #        without overwriting each other - it works well.
+
+               # external variables to be wrapped within the closure
+               valuesIndex   = 0   # points to next value to be processed
+               repeatCounter = 0   # how many repetitions done so far
+
+               # remembers when the current animation sequence started
+               sequenceStartTime = time.time() * 1000.0   # initialize to "now"...
+
+               # define an inner function (closure) that contains the logic of what to do 
+               # with each provided value... 
+               def processEachTimedValueClosure():
+
+                  nonlocal sequenceStartTime   # remembers when the current sequence repetition started
+                  nonlocal valuesIndex         # remembers which value is to be processed this time
+                  nonlocal repeatCounter       # remembers how many times we have processed the complete value list
+
+                  # get current time (in millisecs)
+                  currentTime = time.time() * 1000.0
+                  
+                  # calculate how much time has elapsed since the sequence started
+                  elapsedTime = currentTime - sequenceStartTime
+                  
+                  # get the target timestamp directly from the times list (adjusted by our timeScale)
+                  targetTimestamp = times[valuesIndex] * timeScale
+
+                  # has enough time passed to trigger the next value based on its target timestamp?
+                  if elapsedTime >= targetTimestamp:
+                     
+                     # yes, so...
+                     
+                     # get the arguments directly from the values list
+                     actionArgs = values[valuesIndex]
+                     
+                     # NOTE: this is the important step that advances the animation!!!
+                     # unpack the arguments (*) and execute the original callback
+                     action(*actionArgs)   
+                     
+                     # point to next value to be processed (if any)
+                     valuesIndex = valuesIndex + 1
+
+                     # now, the current value has been processed...
+                        
+                     # have we completed processing all the values?
+                     if valuesIndex >= len(values):   # no more values left?
+                        
+                        # yes, we are done... so, advance to the next repetition (if any)
+                        repeatCounter = repeatCounter + 1
+
+                        # do we have more repetitions?
+                        if repeat == -1 or repeatCounter < repeat:   
+                           
+                           # yes, so start processing values once more
+                           valuesIndex = 0   # point to first value
+                           
+                           # reset the sequence start time for the next repetition cycle
+                           sequenceStartTime = time.time() * 1000.0
+
+                        else:   # we are done repeating, so...
+
+                           # remove this inner function from the engine...
+                           Animate.remove( processEachTimedValueClosure )
+                           
+                           # and execute the callback (if any)
+                           if callable(whenDone):   # is there a completion callback?
+                              
+                              # yes, so execute it!!
+                              whenDone()
+
+                  # now, we have finished processing current value, and have taken care
+                  # of anything else that may have needed to happen (i.e., start over next repetition,
+                  # or called 'whenDone' function, if we are completely done - after this value) 
+
+               # NOTE:  Very important - now that this inner function has been built, 
+               #        we need to register it with our engine, so it can do its job...
+
+               # register the closure to be called - it will take care of everything else...
+               Animate._actionList.append(processEachTimedValueClosure)
+
+
+   @staticmethod
+   def remove(action):
+      """
+      Remove a callback function from the list of functions being called.
+      If a function is registered several times, it removes the earliest addition.
+      """
+      
+      if action in Animate._actionList:   # is this a previously registered function?
+
+         # yes, so remove first matching occurrence
+         Animate._actionList.remove(action)
+
+      else:
+
+         # let them know that something is wrong...
+         print(f"Animate.remove(): '{action}' does not appear in the list of registered functions.")
+
+
+   @staticmethod
+   def getRate():
+      """
+      Return current animation rate (in frames per second).
+      """
+ 
+      # convert milliseconds back to frames per second
+      return int(1000.0 / Animate._interval)
+
+
+   @staticmethod
+   def setRate(frameRate=60):
+      """
+      Set current animation rate (in frames per second).
+      """
+
+      # convert frames per second to milliseconds
+      Animate._interval = (1000.0 / frameRate)
+      
+      if Animate._ENGINE is not None:   # do we have an engine?
+
+         # yes, so update the engine
+         Animate._ENGINE.setDelay(Animate._interval)
+
+
+#####
+# NOTE:  This is important - initialize engine and start master timer at module load time.
+#        Leave it here!!!
+Animate._init()
+
+
+####
+# function aliases for backwards compatibility / simplicity
+def animate(action):
+   """
+   Add a function to be called repeatedly by animation engine.
+   """
+
+   Animate.add(action)
+
+
+def setAnimationRate(frameRate=60):
+   """
+   Set animation frame rate (frames per second).
+   """
+
+   Animate.setRate(frameRate)
+
+   
+def getAnimationRate():
+   """
+   Return current animation frame rate (frames per second).
+   """
+
+   return Animate.getRate()
+
+
+def pauseAnimation():
+   """
+   Pause animation (everything else remains in place).
+   """
+   Animate.pause()
+
+
+def resumeAnimation():
+   """
+   Resume stopped animation (everything continues from where it had left off).
+   """
+
+   Animate.resume()
+
+
+####
+# Helper functions
+
+from music import mapValue   # import mapValue from music library
+
+def mapValueList(values, minValue, maxValue, minResult, maxResult):
+   """
+   Map a sequence of 'values' from their original range (defined by 'minValue' 
+   and 'maxValue') to a new range defined by 'minResult' and 'maxResult'.
+   Returns a new list containing the mapped values.
+   """
+
+   newValues = []   # holds mapped values
+
+   # do some sanity checking...
+   if type(values) is not list:   # are the provided values NOT in a list?
+
+      # let them know something is wrong...
+      print(f"mapValueList(): '{values}' is not a valid list.")
+
+   elif len(values) == 0:   # is the list empty?
+
+      # let them know something is wrong...
+      print("mapValueList(): 'trajectoryValues' list is empty.")
+
+   else:   # all good, so proceed...
+
+      # map each value in provided list
+      for value in values:
+
+         # map this value from source to target range
+         newValue = mapValue(value, minValue, maxValue, minResult, maxResult)
+
+         # and remember it...
+         newValues.append(newValue)
+
+      # now, newValues contains scaled values...
+
+   # and return it (empty, if validation checks fail)
+   return newValues

{creativepython-1.1.6.dist-info → creativepython-1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CreativePython
-Version: 1.1.6
+Version: 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.6.dist-info → creativepython-1.2.dist-info}/RECORD

@@ -1,15 +1,16 @@
-gui.py,sha256=io7p7aYK9EqcP9lBbBO3CBycaAvaHs3IxNw5BrOhhgs,154434
+animation.py,sha256=MwsZS9ERxs_99Q_LP732EOK7oP5E6ZDYKo--JbzxkmY,22893
+gui.py,sha256=X3SDyR0hbGDVRzjc16JqzYiCeHf1hl5nHcY6UpXfn2w,151268
 iannix.py,sha256=jlBJhPzBcIl2iayG01ldoslAytxYOvP3z_vN-EgiJA4,17188
 image.py,sha256=wohpTTZH6QzN3wRfXI5ac7VTRsOKcwqk8_d3yha8oDw,3763
 markov.py,sha256=VhTXZfDDHETj6KhriFmOLHKNjgx08cWZvpLECuGRTG0,24653
 midi.py,sha256=avVY6dyTHbFazt10w2Uy0zUPXvRYleZM2O89gDX3-h4,27203
-music.py,sha256=VyYcjxEIRYG7YWFzBIbSFaR4mVcO2fHDZnkdCh0G4sM,268532
+music.py,sha256=FTDEGCemb8Yy4SVgP7_6fklD7GLPNW7kk1Gvawr7huc,268347
 osc.py,sha256=GtjWV5LD4xiW9Yen3PzFYstWHhEZ_QyrKunAu-VsPrc,8353
 timer.py,sha256=uQ1BHWTjZ6DpJo-leGhxgOJcVcd1Lj0jvQQodXx1kw4,16341
 zipf.py,sha256=J6fWwUYz88LFAwanc0TmXJlU7VtpBM24_Rw5XJTOn9c,40312
 CreativePython/GuiHandler.py,sha256=ONnxhqivBrzCHQv7GcE4vkMgnONbuXXq7Fwe0Au5QPs,30974
-CreativePython/GuiRenderer.py,sha256=XUXhPjtLRUA3D0Q05ZP85gb3gPqg8Zvs732bSYBOVo4,136843
-CreativePython/RealtimeAudioPlayer.py,sha256=tjqBjSOvSvH1kP0t6q35xsbKHPr0wuLUvGdxdWAY73E,44590
+CreativePython/GuiRenderer.py,sha256=bR6mr32G9-VZgLUxXUI34VGYPDCNBm19iONKdGdkUBc,136596
+CreativePython/RealtimeAudioPlayer.py,sha256=Yx79vsXVCQyBw-VVaRHk2FUDTfjxS9Y8coLrnVhjleU,44773
 CreativePython/__init__.py,sha256=bT1nZ-Fp8-7uiKqhVdnFeOwL-8Jps2rvE6BfoOE8fZ0,451
 CreativePython/notationRenderer.py,sha256=2KIMvInNLEUZyn_r1KMmyt7X2XDrfekVkggFeHLRu1M,35440
 CreativePython/nevmuse/RunMetrics.py,sha256=wP5HeS7u5VmH9s-9yyF1EuvF8xFcU6oYTT90Qr16Mu0,4917
@@ -77,9 +78,9 @@ CreativePython/nevmuse/utilities/CSVWriter.py,sha256=k2GccvzD5IwdkmFdN5qtRA2qZX1
 CreativePython/nevmuse/utilities/PowerLawRandom.py,sha256=WIEI-p8wiiWhkkBR5pO9gJ2TwxZBw453T_xXzCNdKPY,3752
 CreativePython/nevmuse/utilities/__init__.py,sha256=pAGIMMGfLvR2DQfxr8qkfKQJ-4fIkVqlhnGK657JPL8,166
 bin/libportaudio.2.dylib,sha256=ooJlm7QeL7jYzc1c8YMmH-C8PhYHwDvBJZkNDVPFRbE,286592
-creativepython-1.1.6.dist-info/licenses/LICENSE,sha256=tz38qDa5RhHMqzZR1Q5QafqWdXn_EhheXYBP7FjgtEM,1992
-creativepython-1.1.6.dist-info/licenses/LICENSE-PSF,sha256=JN1jUPIsEUH1mq3AXxet-b1IdhAr-XzscXBZiz74c9c,3371
-creativepython-1.1.6.dist-info/METADATA,sha256=MGKp9oy0r3G1TsnJxa2M9WtRlP_4X7bGv-05HyB2z0s,8703
-creativepython-1.1.6.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-creativepython-1.1.6.dist-info/top_level.txt,sha256=PzvvUyy-3YzTedVGnLS02ju1TCMuo76h1LuVd8XvHhA,69
-creativepython-1.1.6.dist-info/RECORD,,
+creativepython-1.2.dist-info/licenses/LICENSE,sha256=tz38qDa5RhHMqzZR1Q5QafqWdXn_EhheXYBP7FjgtEM,1992
+creativepython-1.2.dist-info/licenses/LICENSE-PSF,sha256=JN1jUPIsEUH1mq3AXxet-b1IdhAr-XzscXBZiz74c9c,3371
+creativepython-1.2.dist-info/METADATA,sha256=D9cNlCjyoFp4BOp8Gpk5AUgnPEoUNpFkTm9eZPK_fAo,8701
+creativepython-1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+creativepython-1.2.dist-info/top_level.txt,sha256=mgvaKABt8E3WvEYKgGplbpiJqmjFXVCeD4RZIf7EsHs,79
+creativepython-1.2.dist-info/RECORD,,

{creativepython-1.1.6.dist-info → creativepython-1.2.dist-info}/top_level.txt

@@ -1,4 +1,5 @@
 CreativePython
+animation
 bin
 gui
 iannix

gui.py

@@ -2058,9 +2058,18 @@ class Circle(Oval):
       """
       Sets the item's radius (in pixels).
       """
+      # find change in radius
+      oldRadius = self.getRadius()
+      change    = oldRadius - radius
+
+      # adjust radius
       diameter = radius * 2
       self.setWidth(diameter)
 
+      # adjust top-left corner position, since circles are positioned relative to center
+      x, y = self.getPosition()
+      self.setPosition(x + change, y + change)
+
    # ── Hit testing ────────────────────────────────────────────────────────────
 
    def intersects(self, other):
@@ -4207,130 +4216,6 @@ class Menu():
       _handler().sendCommand('disable', self._objectId)
 
 
-#######################################################################################
-# Animate
-#######################################################################################
-# Animate is a static class that can register functions to call repeatedly.  
-# This is essentially a Timer, but with a different API designed for students.
-# This is basic functionality, inspired by MIT Processing's draw() function.  
-# Anything more involved can be easily created using a Timer.
-
-class Animate:
-   """
-   Animate provides methods to animate graphics and other function behavior at a
-   global interval/framerate.
-   """
-   _ENGINE     = None       # animation timer, created the first time add() is called
-   _rate       = 1000 / 60  # current timer interval (in ms)
-   _actionList = []         # list of registered callback functions
-
-   @staticmethod
-   def _startEngine():
-      """
-      Starts the animation engine.
-      """
-      if Animate._ENGINE is None:
-         # create a new engine and start it
-         from timer import Timer
-         Animate._ENGINE = Timer(Animate._rate, Animate.tick, [], True)
-         Animate._ENGINE.start()
-
-   @staticmethod
-   def tick():
-      """
-      Call each registered callback function once.
-      """
-      for action in Animate._actionList:
-         if callable(action):
-            action()
-
-   @staticmethod
-   def resume():
-      """
-      Continues the animation.
-      """
-      if Animate._ENGINE is not None:
-         Animate._ENGINE.start()
-
-   @staticmethod
-   def pause():
-      """
-      Temporarily stops the animation.
-      """
-      if Animate._ENGINE is not None:
-         Animate._ENGINE.stop()
-
-   @staticmethod
-   def add(action):
-      """
-      Register a new callback function to animate.
-      A function can be registered multiple times, but must be removed
-      """
-      if callable(action):
-         Animate._actionList.append(action)
-         Animate._startEngine()   # start lazily on first add, after the fork
-      else:
-         print(f"Animate.add(): '{action.__name__}()' isn't a callable function.")
-
-   @staticmethod
-   def remove(action):
-      """
-      Deregisters a callback function that's being animated.
-      If a function is registered multiple times, this only removes the earliest time it was registered.
-      """
-      if action in Animate._actionList:
-         Animate._actionList.remove(action)
-
-   @staticmethod
-   def getRate():
-      """
-      Returns the current animation rate (in frames per second).
-      """
-      return int(1000 / Animate._rate)
-
-   @staticmethod
-   def setRate(frameRate):
-      """
-      Sets the current animation rate.
-      """
-      Animate._rate = (1000 / frameRate)
-      
-      if Animate._ENGINE is not None:
-         # if an animation is started, also update the engine
-         Animate._ENGINE.setDelay(Animate._rate)
-
-# aliases for backwards compatibility
-def animate(action):
-   """
-   Adds a function to be called repeatedly by the animation engine.
-   """
-   Animate.add(action)
-
-def setAnimationRate(frameRate=60):
-   """
-   Set animation frame rate (frames per second).
-   """
-   Animate.setRate(frameRate)
-   
-def getAnimationRate():
-   """
-   Returns animation frame rate (frames per second).
-   """
-   return Animate.getRate()
-
-def pauseAnimation():
-   """
-   Temporarily stops animation.
-   """
-   Animate.pause()
-
-def resumeAnimation():
-   """
-   Resumes stopped animation.
-   """
-   Animate.resume()
-
-
 #######################################################################################
 # Test
 #######################################################################################

music.py

@@ -2565,7 +2565,7 @@ class Play:
                # (this needs to happen here every time, as we may be using the tempo from score, part, or phrase)
                FACTOR = 1000 * 60.0 / tempo
 
-               for index in range(phrase.length()):      # traverse all notes in this phrase
+               for index in range(phrase.getSize()):      # traverse all notes in this phrase
                   note = phrase.getNote(index)              # and extract needed note data
                   frequency = note.getFrequency()
                   panning = note.getPan()
@@ -3087,6 +3087,40 @@ class Mod():
             compressScore(material, mean, ratio)
       # now, the dynamic of every note has been adjusted
 
+   @staticmethod
+   def crescendo(material, startTime, endTime, startVolume, endVolume):
+      """
+      Linearly interpolates volume from startVolume to endVolume for notes
+      within [startTime, endTime] (quarter notes, MIDI volumes 0-127).
+      Works on a Phrase, Part, or Score.
+      """
+      for name, val in [("startTime", startTime), ("endTime", endTime),
+                        ("startVolume", startVolume), ("endVolume", endVolume)]:
+         if type(val) not in [int, float]:
+            raise TypeError(f"Unrecognized {name} type {type(val)} - expected int or float.")
+
+      if startTime >= endTime:
+         raise ValueError(f"startTime ({startTime}) must be less than endTime ({endTime}).")
+
+      if isinstance(material, Score):
+         for part in material.getPartList():
+            Mod.crescendo(part, startTime, endTime, startVolume, endVolume)
+
+      elif isinstance(material, Part):
+         for phrase in material.getPhraseList():
+            Mod.crescendo(phrase, startTime, endTime, startVolume, endVolume)
+
+      elif isinstance(material, Phrase):
+         durationCounter = material.getStartTime()
+         for note in material.getNoteList():
+            if startTime <= durationCounter < endTime:
+               newVolume = mapValue(durationCounter, startTime, endTime, startVolume, endVolume)
+               note.setDynamic(newVolume)
+            durationCounter += note.getDuration()
+
+      else:
+         raise TypeError(f"Unrecognized material type {type(material)} - expected Phrase, Part, or Score.")
+
    @staticmethod
    def consolidate(part):
       """
@@ -3203,106 +3237,63 @@ class Mod():
    @staticmethod
    def fadeIn(material, fadeLength):
       """
-      Linearly fades in the material (fadeLength is quarter notes).
+      Linearly fades in the material from silence over fadeLength quarter notes,
+      starting from time 0. Works on a Phrase, Part, or Score.
       """
-
-      # define helper functions
-      def fadeInPhrase(phrase, startTime=0.0):
-         """Helper function to fadeIn a single phrase."""
-         durationCounter = startTime                     # track how far into piece we are
-
-         # for each note in phrase
-         for note in phrase.getNoteList():
-            fadeFactor = durationCounter / fadeLength           # calculate fraction of fading needed
-
-            if fadeFactor >= 1:                                 # check if fade is over
-               break
-
-            newDynamic = note.getDynamic() * fadeFactor         # calculate new faded dynamic
-            newDynamic = max(1, newDynamic)                     # keep dynamic above 0
-
-            note.setDynamic(int(newDynamic))                    # update note dynamic
-
-            durationCounter += note.getDuration()               # update time tracker
-
-      def fadeInPart(part, startTime=0.0):
-         """Helper function to fadeIn a single part."""
-         for phrase in part.getPhraseList():
-            fadeInPhrase(phrase, startTime + phrase.getStartTime())
-
-      def fadeInScore(score):
-         """Helper function to fadeIn a score."""
-         for part in score.getPartList():
-            fadeInPart(part, part.getStartTime())
-
-      # check type of time
       if type(fadeLength) not in [float, int]:
          raise TypeError(f"Unrecognized fadeLength type {type(fadeLength)} - expected int or float.")
 
-      # check type of material and call the appropriate function
       if isinstance(material, Score):
-         fadeInScore(material)
+         for part in material.getPartList():
+            Mod.fadeIn(part, fadeLength)
 
       elif isinstance(material, Part):
-         fadeInPart(material)
+         for phrase in material.getPhraseList():
+            Mod.fadeIn(phrase, fadeLength)
 
       elif isinstance(material, Phrase):
-         fadeInPhrase(material)
+         durationCounter = material.getStartTime()
+         for note in material.getNoteList():
+            fadeFactor = durationCounter / fadeLength
+            if fadeFactor >= 1:
+               break
+            note.setDynamic(int(max(1, note.getDynamic() * fadeFactor)))
+            durationCounter += note.getDuration()
 
-      else:   # error check
+      else:
          raise TypeError(f"Unrecognized material type {type(material)} - expected Phrase, Part, or Score.")
 
    @staticmethod
-   def fadeOut(material, fadeLength):
+   def fadeOut(material, fadeLength, _endTime=None):
       """
-      Linearly fades out the material (fadeLength is quarter notes).
+      Linearly fades out the material to silence over the last fadeLength quarter notes.
+      Works on a Phrase, Part, or Score.
       """
+      if type(fadeLength) not in [float, int]:
+         raise TypeError(f"Unrecognized fadeLength type {type(fadeLength)} - expected int or float.")
 
-      # define helper functions
-      def fadeOutPhrase(phrase, endTime):
-         """Helper function to fadeOut a single phrase."""
-         durationCounter = endTime                       # how far from the end are we?
-
-         # for each note in phrase, starting from end
-         for note in phrase.getNoteList()[::-1]:
-               fadeFactor = durationCounter / fadeLength           # calculate fraction of fading needed
-
-               if fadeFactor >= 1:                                 # check if fade is over
-                  break
-
-               newDynamic = note.getDynamic() * fadeFactor         # calculate new faded dynamic
-               newDynamic = max(1, newDynamic)                     # keep dynamic above 0
-
-               note.setDynamic(int(newDynamic))                    # update note dynamic
-
-               durationCounter += note.getDuration()               # update time tracker
-
-      def fadeOutPart(part, endTime):
-         """Helper function to fadeOut a single part."""
-         for phrase in part.getPartList():
-            fadeOutPart(phrase, endTime  - phrase.getEndTime())
-
-      def fadeOutScore(score):
-         """Helper function to fadeOut a score."""
-         for part in score.getPartList():
-               fadeOutPart(part, score.getEndTime() - part.getEndTime())
-
-         # check type of time
-         if type(fadeLength) not in [float, int]:
-            raise TypeError(f"Unrecognized fadeLength type {type(fadeLength)} - expected int or float.")
+      if _endTime is None:
+         _endTime = material.getEndTime()
 
-         # check type of material and call the appropriate function
-         if isinstance(material, Score):
-            fadeOutScore(material)
+      if isinstance(material, Score):
+         for part in material.getPartList():
+            Mod.fadeOut(part, fadeLength, _endTime)
 
-         elif isinstance(material, Part):
-            fadeOutPart(material, 0.0)
+      elif isinstance(material, Part):
+         for phrase in material.getPhraseList():
+            Mod.fadeOut(phrase, fadeLength, _endTime)
 
-         elif isinstance(material, Phrase):
-            fadeOutPhrase(material, 0.0)
+      elif isinstance(material, Phrase):
+         durationCounter = material.getStartTime()
+         for note in material.getNoteList():
+            distFromEnd = _endTime - durationCounter
+            if distFromEnd < fadeLength:
+               fadeFactor = max(0, distFromEnd / fadeLength)
+               note.setDynamic(int(max(1, note.getDynamic() * fadeFactor)))
+            durationCounter += note.getDuration()
 
-         else:   # error check
-            raise TypeError(f"Unrecognized material type {type(material)} - expected Phrase, Part, or Score.")
+      else:
+         raise TypeError(f"Unrecognized material type {type(material)} - expected Phrase, Part, or Score.")
 
    @staticmethod
    def fillRests(material):