CreativePython 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

CreativePython/examples/musicalSphere.py

@@ -15,11 +15,11 @@ from gui import *
 from music import *
 from random import *
 from math import *
-from sliderControl import * 
- 
+from sliderControl import *
+
 class MusicalSphere:
    """Creates a revolving sphere that plays music."""
- 
+
    def __init__(self, radius, density, velocity=0.01, frameRate=30):
       """
       Construct a revolving sphere with given 'radius', 'density'
@@ -28,151 +28,151 @@ class MusicalSphere:
       second.  Each point plays a note when crossing the zero meridian (the
       sphere's meridian (vertical line) closest to the viewer).
       """
- 
+
       # musical parameters
       self.instrument = PIANO
       self.scale = MAJOR_SCALE
       self.lowPitch = C1
       self.highPitch = C6
-      self.noteDuration = 2000    # milliseconds (2 seconds)  
- 
+      self.noteDuration = 2000    # milliseconds (2 seconds)
+
       Play.setInstrument(self.instrument, 0)   # set the instrument
- 
+
       # visual parameters
       self.display = Display("3D Sphere", radius*3, radius*3)  # display to draw sphere
       self.display.setColor( Color.BLACK )  # set background color to black
- 
+
       self.radius = radius       # how wide circle is
       self.numPoints = density   # how many points to draw on sphere surface
       self.velocity = velocity   # how far it rotates per animation frame
       self.frameRate = frameRate # how many animation frames to do per second
- 
+
       self.xCenter = self.display.getWidth() / 2   # to place circle at display's center
       self.yCenter = self.display.getHeight() / 2
- 
+
       # sphere data structure (parallel lists)
       self.points      = []    # holds the points
       self.thetaValues = []    # holds the points' rotation (azimuthal angle)
       self.phiValues   = []    # holds the points' latitude (polar angle)
- 
+
       # timer to drive animation
       delay = 1000 / frameRate   # convert from frame rate to timer delay (in milliseconds)
       self.timer = Timer(delay, self.movePoints)   # timer to schedule movement
- 
+
       # control surface for animation frame rate
       xPosition = self.display.getWidth() / 3    # set initial position of display
       yPosition = self.display.getHeight() + 45
       self.control = SliderControl(title="Frame Rate", updateFunction=self.setFrameRate,
                                    minValue=1, maxValue=120, startValue=self.frameRate,
                                    x=xPosition, y=yPosition)
- 
+
       # orange color gradient (used to display depth, the further away, the darker)
       black = [0, 0, 0]         # RGB values for black
       orange = [251, 147, 14]   # RGB values for orange
       white = [255, 255, 255]   # RGB values for white
- 
+
       # create list of gradient colors from black to orange, and from orange to white
       # (a total of 25 colors)
       self.gradientColors = colorGradient(black, orange, 12) + colorGradient(orange, white, 12) + [white]  # remember to include the final color
- 
+
       self.initSphere()      # create the circle
- 
+
       self.start()           # and start rotating!
- 
+
    def start(self):
       """Starts sphere animation."""
       self.timer.start()
- 
+
    def stop(self):
       """Stops sphere animation."""
       self.timer.stop()
- 
+
    def setFrameRate(self, frameRate=30):
       """Controls speed of sphere animation (by setting how many times per second to move points)."""
- 
+
       delay = 1000 / frameRate   # convert from frame rate to delay between each update (in milliseconds)
       self.timer.setDelay(delay)
- 
+
    def initSphere(self):
       """Generate a sphere of 'radius' out of points (placed on the surface of the sphere)."""
- 
+
       for i in range(self.numPoints):     # create all the points
- 
+
          # get random spherical coordinates for this point
          r = self.radius                                  # all points are placed *on* the surface
          theta = mapValue( random(), 0.0, 1.0, 0.0, 2*pi) # random rotation (azimuthal angle)
          phi = mapValue( random(), 0.0, 1.0, 0.0, pi)     # random latitude (polar angle)
- 
+
          # project from spherical to cartesian 3D coordinates (z is depth)
-         x, y, z = self.sphericalToCartesian(r, phi, theta)  
- 
+         x, y, z = self.sphericalToCartesian(r, phi, theta)
+
          # convert depth (z) to color
-         color = self.depthToColor(z, self.radius)      
- 
-         # create a point (with thickness 1) at these x, y coordinates
-         point = Point(x, y, color, 1)      
- 
+         color = self.depthToColor(z, self.radius)
+
+         # create a point at these x, y coordinates
+         point = Point(x, y, color)
+
          # remember this point and its spherical coordinates (r equals self.radius for all points)
          # (append data for this point to the three parallel lists)
          self.points.append( point )
          self.phiValues.append( phi )
          self.thetaValues.append( theta )
- 
+
          # add this point to the display
          self.display.add( point )
- 
+
    def sphericalToCartesian(self, r, phi, theta):
-      """Convert spherical to cartesian coordinates."""  
- 
+      """Convert spherical to cartesian coordinates."""
+
       # adjust rotation so that theta is 0 at max z (i.e., closest to viewer)
       x = int( r * sin(phi) * cos(theta + pi/2) )   # horizontal axis (pixels are int)
       y = int( r * cos(phi) )                       # vertical axis
-      z = int( r * sin(phi) * sin(theta + pi/2) )   # depth axis      
- 
+      z = int( r * sin(phi) * sin(theta + pi/2) )   # depth axis
+
       # move sphere's center to display's center
       x = x + self.xCenter
       y = y + self.yCenter
- 
+
       return x, y, z
- 
+
    def depthToColor(self, depth, radius):
       """Map 'depth' to color using the 'gradientColors' RGB colors."""
- 
+
       # create color based on position (points further away have less luminosity)
       colorIndex = mapValue(depth, -self.radius, self.radius, 0, len(self.gradientColors))  # map depth to color index
       colorRGB = self.gradientColors[colorIndex]                    # get corresponding RBG value
       color = Color(colorRGB[0], colorRGB[1], colorRGB[2])          # and create the color
- 
+
       return color
- 
+
    def movePoints(self):
       """Rotate points on y axis as specified by angular velocity."""
- 
+
       for i in range(self.numPoints):
          point = self.points[i]                                   # get this point
          theta = (self.thetaValues[i] + self.velocity) % (2*pi)   # increment angle to simulate rotation
          phi = self.phiValues[i]                                  # get latitude (altitude)
- 
+
          # convert from spherical to cartesian 3D coordinates
          x, y, z = self.sphericalToCartesian(self.radius, phi, theta)
- 
+
          if self.thetaValues[i] > theta:   # did we just cross the primary meridian?
             color = Color.RED                  # yes, so sparkle for a split second
             pitch = mapScale(phi, 0, pi, self.lowPitch, self.highPitch, self.scale)  # phi is latitude
             dynamic = randint(0, 127)          # random dynamic
             Play.note(pitch, 0, self.noteDuration, dynamic)  # and play a note (based on latitude)
- 
+
          else:   # we are not on the primary meridian, so
             # convert depth to color (points further away have less luminosity)
             color = self.depthToColor(z, self.radius)
- 
+
          # adjust this point's position and color
          self.display.move(point, x, y)
          point.setColor(color)
- 
+
          # now, remember this point's new theta coordinate
          self.thetaValues[i] = theta
- 
+
 #################################################
 # create a sphere
 sphere = MusicalSphere(radius=200, density=200, velocity=0.01, frameRate=30)

_RealtimeAudioPlayer.py

@@ -8,6 +8,7 @@
 #
 #######################################################################################
 # TODO:
+# - rewrite to avoid early returns/breaks
 #
 #######################################################################################
 
@@ -18,7 +19,7 @@ import os                 # for file path operations
 import math               # for logarithmic calculations in pitch/frequency conversions
 
 
-#### Helper Functions #################################################################
+#### Helper Conversion Functions #################################################################
 
 def freqToNote(frequency):
    """Converts frequency to the closest MIDI note number with pitch bend value
@@ -48,7 +49,6 @@ def noteToFreq(pitch):
 
    return frequency
 
-
 ##### Real-Time Audio Player Class ########################################################
 
 class _RealtimeAudioPlayer:
@@ -173,7 +173,34 @@ class _RealtimeAudioPlayer:
       elif not self.looping:   # not looping
          self.loopCountTarget = 0   # play once then stop
 
-      # print(f"For '{os.path.basename(self.filepath)}', BasePitch={self.basePitch:.2f}, BaseFreq={self.baseFrequency:.2f}Hz.")
+      # IMPORTANT: Pre-allocate the audio stream for maximum efficiency.
+      # The stream is created but not started until play() is called.
+      # This eliminates the need for stream creation/deletion during each playback.
+      self._createStream()
+
+
+   def _createStream(self):
+      """
+      Creates and starts the audio stream. This method is called during initialization
+      to pre-allocate the stream for maximum efficiency.
+      """
+
+      try:
+         # create the sounddevice output stream for playback
+         self.sdStream = sd.OutputStream(
+            samplerate=self.sampleRate,
+            blocksize=self.chunkSize,
+            channels=self.numChannels,
+            callback=self.audioCallback
+         )
+
+         # Don't start the stream here - it will be started in play() method
+         # self.sdStream.start()  # Stream will be started when needed
+
+      except Exception as e:
+         print(f"Error creating audio stream: {e}")
+         self.sdStream = None
+         raise
 
 
    def _findNextZeroCrossing(self, startFrameFloat, searchWindowFrames=256):
@@ -339,7 +366,7 @@ class _RealtimeAudioPlayer:
       originalTargetFrameFloat = timeSeconds * self.sampleRate
 
       # basic ZC adjustment for now, will be enhanced with fade-seek-fade
-      actualTargetFrame = self.findNextZeroCrossing(originalTargetFrameFloat)
+      actualTargetFrame = self._findNextZeroCrossing(originalTargetFrameFloat)
 
       # if playing and conditions met for smooth seek
       if actualTargetFrame >= self.numFrames and not self.looping:
@@ -400,14 +427,12 @@ class _RealtimeAudioPlayer:
             self.isPlaying = False
             self.isApplyingFadeOut = False
             self.isFadingOutToStop = False
-            # no need to raise CallbackStop here, as returning normally from a callback while
-            # the stream is active and isPlaying is false will lead to it being stopped by play/stop logic.
 
-         return # exit the callback early, providing silence.
+         return   # exit the callback early, providing silence.
 
       numOutputChannels = outdata.shape[1]   # get number of output channels (1=mono, 2=stereo)
 
-      # initialize chunkBuffer matching the output stream's channel count and frame count for this callback.
+      # Initialize chunkBuffer matching the output stream's channel count and frame count for this callback.
       # This buffer will be filled with processed audio samples one by one before being copied to `outdata`.
       # Using an intermediate buffer like this is common for clarity and for complex processing steps.
       chunkBuffer = np.zeros((frames, numOutputChannels), dtype=np.float32)
@@ -419,9 +444,9 @@ class _RealtimeAudioPlayer:
             # If isPlaying became false (e.g., due to a fade-out completing and setting isPlaying to False,
             # or an external stop() call), we should fill the rest of this chunk with silence
             # and then break out of this sample-processing loop.
-            chunkBuffer[i:] = 0.0 # fill remaining part of the buffer with silence
-            break # exit per-sample loop
-            # TODO: rewrite to avoid early break
+
+            chunkBuffer[i:] = 0.0   # fill remaining part of the buffer with silence
+            break   # exit per-sample loop
 
          #### Determine current sample value with interpolation (and hard loop if enabled)
          # To play audio at different speeds (self.rateFactor != 1.0) or for smooth playback,
@@ -432,7 +457,7 @@ class _RealtimeAudioPlayer:
          readPosInt2 = readPosInt1 + 1                 # next actual sample index
          fraction = readPosFloat - readPosInt1         # the fractional part, how far between readPosInt1 and readPosInt2 we are.
 
-         # Clamp read positions to be safe for array access, *after* potential looping adjustment
+         # Clamp read positions to be safe for array access, *after* potential looping adjustment.
          # This ensures that we don't try to read outside the bounds of our audioData array.
          readPosInt1 = max(0, min(readPosInt1, self.numFrames - 1))   # ensure read position 1 is valid
          readPosInt2 = max(0, min(readPosInt2, self.numFrames - 1))   # ensure read position 2 is also valid
@@ -473,10 +498,10 @@ class _RealtimeAudioPlayer:
          # the overall volume of the sample is scaled by self.volumeFactor
          processedSample = currentSampleArray * self.volumeFactor
 
-         #### Apply Master Fades (Fade-in and Fade-out) ---
+         #### Apply Master Fades (Fade-in and Fade-out)
          # Fades are applied by smoothly changing a gain envelope from 0 to 1 (fade-in)
          # or 1 to 0 (fade-out) over a specified number of frames.
-         gainEnvelope = 1.0 # start with full gain, adjust if fading.
+         gainEnvelope = 1.0   # start with full gain, adjust if fading.
 
          if self.isApplyingFadeIn:   # is fade-in currently being applied?
 
@@ -564,7 +589,7 @@ class _RealtimeAudioPlayer:
 
          # This is the point at which we should either loop or stop for the current play segment,
          # so determine the effective end frame for the current segment/loop
-         effectiveSegmentEndFrame = self.numFrames -1 # default to end of file
+         effectiveSegmentEndFrame = self.numFrames -1   # default to end of file
 
          if self.looping and self.loopRegionEndFrame > 0:
             # if looping and a specific loop region end is defined, that's our segment end
@@ -614,7 +639,6 @@ class _RealtimeAudioPlayer:
          if not self.isPlaying:
             chunkBuffer[i:] = 0.0 # fill remaining part of this chunk with silence
             break # exit per-sample loop
-            # TODO: rewrite to avoid break
 
       #### End of per-sample loop (for i in range(frames))
 
@@ -649,12 +673,9 @@ class _RealtimeAudioPlayer:
       outdata[:] = np.clip(chunkBuffer, -1.0, 1.0)
 
       #### Handle stream stopping conditions
-      # NOTE: If isPlaying became False during this callback (e.g., by fade-out completion or natural end)
-      # raise CallbackStop to tell PortAudio to stop invoking this callback.
-      # This is the primary mechanism for cleanly stopping the audio stream from within the callback
-      # when playback is logically complete or has been requested to stop.
-      if not self.isPlaying:
-         raise sd.CallbackStop
+      # NOTE: Streams are now properly started/stopped by play()/stop() methods
+      # This provides cleaner audio management and prevents interference between multiple voices
+      # The stream will be stopped when playback ends or stop() is called
 
       #### end of audioCallback
 
@@ -752,7 +773,7 @@ class _RealtimeAudioPlayer:
       if not self.isPlaying:
 
          if self.playbackPosition >= self.numFrames and not self.looping:
-            self.playbackPosition = 0.0 # or self._findNextZeroCrossing(0.0)
+            self.playbackPosition = 0.0   # or self._findNextZeroCrossing(0.0)
 
          self.playbackEndedNaturally = False   # playback did not reach the end
 
@@ -761,75 +782,31 @@ class _RealtimeAudioPlayer:
             self.isApplyingFadeIn = True
             self.fadeInFramesProcessed = 0
 
+            # Use the pre-allocated stream - start it if it's not already running
             if self.sdStream and not self.sdStream.closed:
-               # NOTE: If stream exists but was stopped (e.g. by isPlaying = False in callback)
-               # It needs to be closed and reopened, or sounddevice's start() might not work as expected
-               # or might resume from an odd state. Safest is to ensure clean start.
-               self.sdStream.close() # ensure previous instance is closed
-
-            # create the sounddevice output stream for playback
-            self.sdStream = sd.OutputStream(
-               samplerate=self.sampleRate,
-               blocksize=self.chunkSize,
-               channels=self.numChannels,
-               callback=self.audioCallback,
-               finished_callback=self.onPlaybackFinished
-            )
-
-            # start the sounddevice output stream
-            self.sdStream.start()
-            self.isPlaying = True
-            self.playbackEndedNaturally = False   # reset this flag as we are starting
-
-         except Exception as e:   # sounddevice stream did not start
-            print(f"Error starting sounddevice stream: {e}")
-            self.isPlaying = False
+               if self.sdStream.stopped:
+                  # Stream exists but is stopped, so start it
+                  self.sdStream.start()
 
-            if self.sdStream:
-               self.sdStream.close() # ensure cleanup if start failed
-            self.sdStream = None
-
-            # do not re-raise here, allow AudioSample to handle or log
-            return   # exit since stream failed to start
-            # TODO: rewrite to avoid early return
+               self.isPlaying = True
+               self.playbackEndedNaturally = False
+            else:
+               # Stream was somehow lost - recreate it
+               self._createStream()
+               self.sdStream.start()  # Start the newly created stream
+               self.isPlaying = True
+               self.playbackEndedNaturally = False
+
+         except Exception as e:   # stream recreation failed
+            print(f"Error with audio stream: {e}")
+            self.isPlaying = False
+            return   # exit since stream failed
 
          if startAtBeginning and self.isPlaying:   # check isPlaying again in case it was set by new stream
             self.isApplyingFadeIn = True
             self.fadeInFramesProcessed = 0
 
 
-   def onPlaybackFinished(self):
-      # NOTE: This callback is called when the stream is stopped or aborted.
-      # self.isPlaying = False # Stream is already stopped, this reflects state
-      # Don't reset looping here, it's a persistent setting.
-      # Don't reset playbackPosition here, might be needed for resume or query.
-
-      # close the sounddevice stream if it exists and is not already closed
-      if self.sdStream and not self.sdStream.closed:
-
-         try:   # handle possible exceptions during stream closure (e.g., at interpreter exit)
-            self.sdStream.close()   # close the stream to release audio resources
-
-         except sd.PortAudioError as pae:
-
-            if pae.args[1] == sd.PaErrorCode.paNotInitialized:
-               pass   # portaudio already terminated, which is expected during atexit
-
-            else:
-               print(f"PortAudioError closing stream: {pae}")
-
-         except Exception as e:
-            print(f"Generic error closing PortAudio stream: {e}")
-
-      self.sdStream = None   # clear the stream reference after closing
-
-      # Now, if it was a fade out to stop, the isPlaying should already be false.
-      # If it stopped for other reasons (e.g. error, or CallbackStop raised not due to fade),
-      # ensure isPlaying is False.
-      # However, self.isPlaying is primarily controlled by play() and stop() and callback logic.
-      # this finished_callback is more for resource cleanup.
-
-
    def getLoopsPerformed(self):
       return self.loopsPerformed  # number of loops completed
 
@@ -846,25 +823,13 @@ class _RealtimeAudioPlayer:
       # handle case where already stopped (but may have pending fade-out)
       if not self.isPlaying and not self.isApplyingFadeOut:
 
-         # ensure stream is actually closed if somehow isPlaying is False but stream exists
-         if self.sdStream and not self.sdStream.closed:
-
+         # Ensure stream is stopped when not playing
+         if self.sdStream and not self.sdStream.stopped:
             try:
-               self.sdStream.close()   # close the audio stream
-
-            except sd.PortAudioError as pae:
-
-               if pae.args[1] == sd.PaErrorCode.paNotInitialized:
-                  pass   # ignore if PortAudio already terminated
-
-               else:
-                  print(f"Error closing PyAudio stream: {pae}")
-
+               self.sdStream.stop()
             except Exception as e:
-               print(f"Generic error closing PyAudio stream: {e}")
-
-            finally:
-               self.sdStream = None   # clear stream reference
+               # Ignore errors during cleanup
+               pass
 
          # reset all playback state variables
          self.isPlaying = False   # confirm stopped state
@@ -877,7 +842,6 @@ class _RealtimeAudioPlayer:
          self.loopCountTarget = -1 if self.looping else 0   # reset to constructor state
          self.loopsPerformed = 0   # reset loop counter
          return   # done, since already stopped
-         # TODO: rewrite without early return
 
       # handle immediate stop (skip fade-out for instant termination)
       if immediate:
@@ -887,34 +851,13 @@ class _RealtimeAudioPlayer:
          self.isApplyingFadeOut = False   # cancel any ongoing fade-out (e.g. from pause)
          self.isFadingOutToStop = False   # ensure fade-out-to-stop is reset
 
-         # handle immediate stream termination
-         if self.sdStream:
-
+         # Stop the stream when stopping immediately
+         if self.sdStream and not self.sdStream.stopped:
             try:
-               # check if stream is active before trying to stop
-
-               if not self.sdStream.stopped:
-                  self.sdStream.stop()   # stop the PortAudio stream immediately
-
-               # re-check self.sdStream because .stop() could have called _onPlaybackFinished
-               # which sets self.sdStream to None
-
-               if self.sdStream and not self.sdStream.closed:
-                  self.sdStream.close()   # close and release resources
-
-            except sd.PortAudioError as pae:
-
-               if pae.args[1] == sd.PaErrorCode.paNotInitialized:
-                  pass   # PortAudio already terminated, expected during atexit or rapid stop/close
-
-               else:
-                  print(f"PortAudioError during immediate stream stop/close: {pae}")
-
+               self.sdStream.stop()
             except Exception as e:
-               print(f"Error during immediate stream stop/close: {e}")
-
-            finally:
-               self.sdStream = None   # discard stream instance
+               # Ignore errors during cleanup
+               pass
 
          # reset all playback state variables for immediate stop
          self.targetEndSourceFrame = -1.0       # reset end frame target
@@ -946,18 +889,16 @@ class _RealtimeAudioPlayer:
       self.isFadingOutToStop = False
 
       if self.sdStream:
-
          try:
             # check if stream is active before trying to stop
             if not self.sdStream.stopped:
                self.sdStream.stop()   # stop stream activity
 
-            # re-check because .stop() could have called onPlaybackFinished
+            # re-check because .stop() could have been called
             if not self.sdStream.closed:
                self.sdStream.close()   # release resources
 
          except sd.PortAudioError as pae:
-
             # if PortAudio is already uninitialized (e.g. during atexit), these calls can fail.
             if pae.args[1] == sd.PaErrorCode.paNotInitialized:   # paNotInitialized = -10000
                pass   # suppress error if PortAudio is already down
@@ -969,6 +910,27 @@ class _RealtimeAudioPlayer:
             self.sdStream = None
 
 
+   def forceCloseStream(self):
+      """
+      Explicitly closes the audio stream. This is useful when you want to ensure
+      a fresh stream is created on the next play() call, or when cleaning up resources.
+      """
+      if self.sdStream:
+         try:
+            if not self.sdStream.stopped:
+               self.sdStream.stop()
+            if not self.sdStream.closed:
+               self.sdStream.close()
+         except Exception as e:
+            # ignore errors during cleanup
+            pass
+         finally:
+            self.sdStream = None
+
+      # Recreate the stream for future use
+      self._createStream()
+
+
    def __del__(self):
       # call close() to ensure resources are released
       self.close()

{creativepython-0.1.6.dist-info → creativepython-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CreativePython
-Version: 0.1.6
+Version: 0.1.7
 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
@@ -33,6 +33,7 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: setuptools>=69.0
 Requires-Dist: tinysoundfont>=0.3.6
 Requires-Dist: osc4py3>=1.0.8
 Requires-Dist: mido>=1.3.3
@@ -164,7 +165,7 @@ After you do, you should hear a single C4 half-note.
 
 Some of CreativePython's libraries need to compile C++ code during installation.
 
-- On Windows, download and install [Visual Studio Build Tools 2022](https://visualstudio.microsoft.com/downloads/).  In the Visual Studio installer, make sure "C++ Build Tools" is checked.
+- On Windows, download and install [Visual Studio Build Tools 2022](https://visualstudio.microsoft.com/downloads/).  In the Visual Studio installer, make sure "Desktop Development with C++" is checked.
 
 - On MacOS, you can download and install [XCode from the App Store](https://apps.apple.com/us/app/xcode/id497799835?mt=12).
 

{creativepython-0.1.6.dist-info → creativepython-0.1.7.dist-info}/RECORD

@@ -1,11 +1,11 @@
-_RealtimeAudioPlayer.py,sha256=KJjolBwX8GScKGnWE8Qpydb0bsWvu8Z6uQF78BnApUg,49068
-gui.py,sha256=jnh2oNv7eplZQe8HhMd5IIrl2vKSE0R9StI8-i5e5jI,136204
+_RealtimeAudioPlayer.py,sha256=AHKDE4etmfRgwyUG3SIoEblXoPaFUk9oxQLy1BgDFP8,46808
+gui.py,sha256=eKiJgMgSdHBoR6m5k0vIoVSoh2hmDNvJEgcWj1ima7w,140074
 iannix.py,sha256=Ixl_wiFqIMyAWO4eAcIJvyNAuJ8alTrkSGXu8ruhVug,17162
 image.py,sha256=8TEKOREWnIFpOKZBqrdTGeiQV2vN09texrb_nAzgorw,2739
 markov.py,sha256=UXXHDJ6Y1BItACpa9vSRjSb1wfIedv7T1GuHqpnvzWE,24407
-midi.py,sha256=phcaTdSfx9Q5LwojPD3nZp4PXHcnWsSREbZNDojYczs,40056
-music.py,sha256=SJ7cBQ5PXcFvJFzlF4FzYJlmxL4MSuu7iIC4G3WYyM0,223160
-osc.py,sha256=14zGel-KPiU226i1SWUGXYWEPG6v_AntGRw0KiPQu0Y,16244
+midi.py,sha256=gpvrSBESD6z8XprDQD1xANQf-p1Id4X9arHcSw9W46o,42216
+music.py,sha256=R26IEDcYvJ9LsO7n6zKNnrLSujHfSeTj2TfuBClpaGs,224290
+osc.py,sha256=38I_wd2Nlxu3FgNnowidbDeGH5jSxJozL5zNVPadLq8,18638
 timer.py,sha256=jCOqnIc7oXbCTPYahvupO3wOo1AJmyPGA8FHVv5xaP0,22477
 zipf.py,sha256=u1xZxfiCEqsNuX9mMOHVunikWPjCGK-6kzl99ZfimH8,30119
 CreativePython/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -59,7 +59,7 @@ CreativePython/examples/midiOut.b.py,sha256=N1TazkSMXI5D3BODrf4faqtzu2ZaE2AdTh8f
 CreativePython/examples/midiSynthesizer.py,sha256=Bz7TbFsw2DKNaskxKsYiPq-7fJ9TNPPAUUjjiNgkW0g,808
 CreativePython/examples/midiSynthesizer2.py,sha256=a9KlKBOeqvJuIpbrB3Ybbr3mqh_PGI4IPbqByKoGH60,1552
 CreativePython/examples/moondog-bird_slament.wav,sha256=fcux66G_0DJW7tJAYgI328CvBW81NRy0vettW1w6Yos,727084
-CreativePython/examples/musicalSphere.py,sha256=bcdnwvnZR5s4UJ2xlm8qgByKqiFdM0mEKsR0NMUYsPc,8048
+CreativePython/examples/musicalSphere.py,sha256=lg0Q8fbvxhEEL14IHh-Lv22HpV3Vyqo40uamzJDZiPc,7960
 CreativePython/examples/note.py,sha256=N51kqwd4B2a-ZR6GVH_mVS7wDYjpgyuskhQRAkii23A,1913
 CreativePython/examples/octoplus.py,sha256=XDTVjMKuRKbaCJKriN2CzBj2iIYZBTDr81TMJm_9JTc,1817
 CreativePython/examples/oscIn1.py,sha256=Er2o9wlsmiqxmJKg-NlMw6fGDEGISm8QCLe5Niko5IM,219
@@ -97,8 +97,8 @@ CreativePython/resources/.DS_Store,sha256=1lFlJ5EFymdzGAUAaI30vcaaLHt3F1LwpG7xIL
 CreativePython/resources/550973__luizguilherme_a__clean-guitarr-riff.mp3,sha256=hUO6BU7VbaRv6QpjjPvi5cVnrGuR8AXTVOcw-BaDd0k,147856
 CreativePython/resources/chopper.jpg,sha256=AykvUOwRSDi4g6OpfcNQ-LgwPE05_eVkCv5E9lnhUbk,135266
 CreativePython/resources/de-brazzas-monkey.jpg,sha256=AFCxemqkDYv_TPpcLwrHnTtoxGduvZD7O2S0xMqQ4C0,119054
-creativepython-0.1.6.dist-info/licenses/LICENSE,sha256=1hbJHc1vxY4vAasDE4CMC4wDH91CBz5B-rgfujDntTw,1073
-creativepython-0.1.6.dist-info/METADATA,sha256=UTJpq7BCP712qm4t2hD3CVBm95mr0zE6UKG-QyC_mmc,6380
-creativepython-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-creativepython-0.1.6.dist-info/top_level.txt,sha256=hr9Bb2GEFRCKQRsdmtS62vxm9eK3knxLkZjePwcS72M,86
-creativepython-0.1.6.dist-info/RECORD,,
+creativepython-0.1.7.dist-info/licenses/LICENSE,sha256=1hbJHc1vxY4vAasDE4CMC4wDH91CBz5B-rgfujDntTw,1073
+creativepython-0.1.7.dist-info/METADATA,sha256=0hr44zeN928R6AvKgw0oU8Po0g_2ZYbnlq9aQJW55G0,6425
+creativepython-0.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+creativepython-0.1.7.dist-info/top_level.txt,sha256=hr9Bb2GEFRCKQRsdmtS62vxm9eK3knxLkZjePwcS72M,86
+creativepython-0.1.7.dist-info/RECORD,,