CreativePython 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

CreativePython/AudioSample.py → AudioSample.py

@@ -137,6 +137,10 @@ class AudioSample:
          # and corresponds to basePitch/baseFrequency. No need to call setPitch/setFrequency here
          # unless we wanted it to start differently from its base.
 
+      # Initialize voice management attributes
+      self.freeVoices = list(range(self.maxVoices))  # holds list of free voices (numbered 0 to maxVoices-1)
+      self.voicesAllocatedToPitch = {}  # a dictionary of voice lists - indexed by pitch (several voices per pitch is possible)
+
       _activeAudioSamples.append(self)
 
    def play(self, start=0, size=-1, voice=0):
@@ -178,12 +182,12 @@ class AudioSample:
 
       # Store non-looping settings (or settings for a single iteration if size is given)
       self._currentLoopSettings[voice] = {
-          'active': False, # signifies it's a play-once (or play-duration)
-          'loopCountTarget': 0, # ensures it's treated as non-looping by RTA if loop=False
-          'loopRegionStartFrame': loop_region_start_f,
-          'loopRegionEndFrame': -1.0, # not critical for non-looping, RTA uses targetEndSourceFrame based on duration
-          'loopsPerformedCurrent': 0,
-          'playDurationSourceFrames': calculated_play_duration_source_frames # store this for resume
+         'active': False, # signifies it's a play-once (or play-duration)
+         'loopCountTarget': 0, # ensures it's treated as non-looping by RTA if loop=False
+         'loopRegionStartFrame': loop_region_start_f,
+         'loopRegionEndFrame': -1.0, # not critical for non-looping, RTA uses targetEndSourceFrame based on duration
+         'loopsPerformedCurrent': 0,
+         'playDurationSourceFrames': calculated_play_duration_source_frames # store this for resume
       }
 
       # ensure the player is set to not loop for this single play command.
@@ -259,12 +263,12 @@ class AudioSample:
 
       # Store loop settings for this voice
       self._currentLoopSettings[voice] = {
-          'active': playerShouldLoop,
-          'loopCountTarget': actualLoopCountTarget,
-          'loopRegionStartFrame': loopRegionStartFrames,
-          'loopRegionEndFrame': loopRegionEndFrames,
-          'loopsPerformedCurrent': 0, # Reset on new loop command
-          'playDurationSourceFrames': -1.0 # Not used for active looping
+         'active': playerShouldLoop,
+         'loopCountTarget': actualLoopCountTarget,
+         'loopRegionStartFrame': loopRegionStartFrames,
+         'loopRegionEndFrame': loopRegionEndFrames,
+         'loopsPerformedCurrent': 0, # Reset on new loop command
+         'playDurationSourceFrames': -1.0 # Not used for active looping
       }
 
       player.play(startAtBeginning=startAtBeginningOfLoopSegment, # True to make it start from loop_region_start_frames
@@ -286,18 +290,18 @@ class AudioSample:
          voice = 0
 
       player = self._players[voice]
-      player.stop(immediate=True) # Corresponds to API "Stops sample playback immediately"
+      player.stop(immediate=True) # stop sample playback immediately
 
-      # Reset loop settings for this voice to default non-looping
+      # reset loop settings for this voice to default non-looping
       self._currentLoopSettings[voice] = {
-          'active': False,
-          'loopCountTarget': 0,
-          'loopRegionStartFrame': 0.0,
-          'loopRegionEndFrame': -1.0,
-          'loopsPerformedCurrent': 0,
-          'playDurationSourceFrames': -1.0
+         'active': False,
+         'loopCountTarget': 0,
+         'loopRegionStartFrame': 0.0,
+         'loopRegionEndFrame': -1.0,
+         'loopsPerformedCurrent': 0,
+         'playDurationSourceFrames': -1.0
       }
-      self._isPausedFlags[voice] = False # Reset pause state on stop
+      self._isPausedFlags[voice] = False # reset pause state on stop
 
    def isPlaying(self, voice=0):
       """
@@ -379,13 +383,13 @@ class AudioSample:
             play_duration_for_resume = loop_settings.get('playDurationSourceFrames', -1.0)
 
          player.play(
-             startAtBeginning=False, # resume from current player.playbackPosition
-             loop=loop_settings['active'],
-             playDurationSourceFrames=play_duration_for_resume,
-             loopRegionStartFrame=loop_settings['loopRegionStartFrame'],
-             loopRegionEndFrame=loop_settings['loopRegionEndFrame'],
-             loopCountTarget=loop_settings['loopCountTarget'],
-             initialLoopsPerformed=loop_settings['loopsPerformedCurrent'] # pass stored count
+            startAtBeginning=False, # resume from current player.playbackPosition
+            loop=loop_settings['active'],
+            playDurationSourceFrames=play_duration_for_resume,
+            loopRegionStartFrame=loop_settings['loopRegionStartFrame'],
+            loopRegionEndFrame=loop_settings['loopRegionEndFrame'],
+            loopCountTarget=loop_settings['loopCountTarget'],
+            initialLoopsPerformed=loop_settings['loopsPerformedCurrent'] # pass stored count
          )
          self._isPausedFlags[voice] = False
       else:
@@ -603,7 +607,7 @@ class AudioSample:
 
       if voiceForThisPitch != None:   # if a free voice exists...
          # associate it with this pitch
-         if not self.voicesAllocatedToPitch.has_key(pitch):   # new pitch (not sounding already)?
+         if pitch not in self.voicesAllocatedToPitch:   # new pitch (not sounding already)?
             self.voicesAllocatedToPitch[pitch] = [voiceForThisPitch]         # remember that this voice is playing this pitch
          else:   # there is at least one other voice playing this pitch, so...
             self.voicesAllocatedToPitch[pitch].append( voiceForThisPitch )   # append this voice (mimicking MIDI standard for polyphony of same pitches!!!)
@@ -642,7 +646,7 @@ class AudioSample:
 
       voice = None   # initialize
 
-      if self.voicesAllocatedToPitch.has_key(pitch) and len( self.voicesAllocatedToPitch[pitch] ) > 0:   # does this pitch have voices allocated to it?
+      if pitch in self.voicesAllocatedToPitch and len( self.voicesAllocatedToPitch[pitch] ) > 0:   # does this pitch have voices allocated to it?
          voice = self.voicesAllocatedToPitch[pitch][0]   # first voice used for this pitch
       else:   # pitch is not currently sounding, so...
          raise ValueError("Pitch (" + str(pitch) + ") is not currently playing!!!")
@@ -664,7 +668,7 @@ class AudioSample:
          raise TypeError("Pitch (" + str(pitch) + ") should be an int (range 0 and 127) or float (such as 440.0).")
 
       # now, assume pitch contains a frequency (float)
-      if self.voicesAllocatedToPitch.has_key(pitch) and len( self.voicesAllocatedToPitch[pitch] ) > 0:   # does this pitch have voices allocated to it?
+      if pitch in self.voicesAllocatedToPitch and len( self.voicesAllocatedToPitch[pitch] ) > 0:   # does this pitch have voices allocated to it?
          freedVoice = self.voicesAllocatedToPitch[pitch].pop(0)   # deallocate first voice used for this pitch
          self.freeVoices.append( freedVoice )                     # and return it back to the pool of free voices
 
@@ -708,6 +712,228 @@ class AudioSample:
             # this can happen if close() is called multiple times.
             pass
 
+
+class Envelope():
+   """ This class knows how to adjust the volume of an Audio Sample over time, in order to help shape its sound.
+
+      It consists of:
+
+        - a list of attack times (in milliseconds, relative from the previous time),
+        - a list of volumes - to be reached at the correspondng attack times (parallel lists),
+        - the delay time (in milliseconds - relative from the last attack time), of how long to wait to get to the sustain value (see next),
+        - the sustain value (volume to maintain while sustaining), and
+        - the release time (in milliseconds, relative from the END of the sound) - how long the fade-out is, i.e., to reach a volume of zero.
+
+        NOTE:  Notice how all time values are relative to the previous one, with the exception of
+
+               - the first attack value, which is relative the start of the sound, and
+               - the release time, which is relative to (goes beyond) the end of the sound.
+
+        This last one is VERY important - i.e., release time goes past the end of the sound!!!
+   """
+
+   def __init__(self, attackTimes = [2, 20], attackVolumes = [0.5, 0.8], delayTime = 20, sustainVolume = 1.0, releaseTime = 150):
+      """
+      attack times   - in milliseconds, first one is from start of sound, all others are relative to the previous one
+      attack volumes - range from 0.0 (silence) to 1.0 (max), parallel to attack times - volumes to reach at corresponding times
+      delay time     - in milliseconds, relative from the last attack time - how long to wait to reach to sustain volume (see next)
+      sustain volume - 0.0 to 1.0, volume to maintain while playing the main body of the sound
+      release time   - in milliseconds, relative to the END of the sound - how long to fade out (after end of sound).
+      """
+
+      self.attackTimes    = None   # in milliseconds, relative from previous time
+      self.attackVolumes  = None   # and the corresponding volumes
+      self.delayTime      = None   # in milliseconds, relative from previous time
+      self.sustainVolume  = None   # to reach this volume
+      self.releaseTime    = None   # in milliseconds, length of fade out - beyond END of sound
+
+      # udpate above values (this will do appropriate error checks, so that we do not repeat that code twice here)
+      self.setAttackTimesAndVolumes(attackTimes, attackVolumes)
+      self.setDelayTime(delayTime)
+      self.setSustainVolume(sustainVolume)
+      self.setReleaseTime(releaseTime)
+
+
+   def setAttackTimesAndVolumes(self, attackTimes, attackVolumes):
+      """ Sets attack times and volumes. Attack times are in milliseconds, relative from previous time (first one is from start of sound).
+          Attack volumes are between 0.0 and 1.0, and are the corresponding volumes to be set at the given times.
+
+            NOTE:  We do not provide individual functions to set attack times and to set volumes,
+            as it is very hard to check for parallelism (same length constraint) - a chicken-and-egg problem...
+      """
+
+      # make sure attack times and volumes are parallel
+      if len(attackTimes) != len(attackVolumes):
+
+         raise IndexError("Attack times and volumes must have the same length.")
+
+      # make sure attack times are all ints, greater than zero
+      for attackTime in attackTimes:
+
+         if attackTime < 0:
+
+            raise ValueError("Attack times should be zero or positive (found " + str(attackTime) + ").")
+
+      # make sure attack volumes are all floats between 0.0 and 1.0 (inclusive).
+      for attackVolume in attackVolumes:
+
+         if attackVolume < 0.0 or 1.0 < attackVolume:
+
+            raise ValueError("Attack volumes should be between 0.0 and 1.0 (found " + str(attackVolume) + ").")
+
+      # all well, so update
+      self.attackTimes   = attackTimes
+      self.attackVolumes = attackVolumes
+
+
+   def getAttackTimesAndVolumes(self):
+      """ Returns list of attack times and corresponding volumes. No need for individual getter functions - these lists go together. """
+
+      return [self.attackTimes, self.attackVolumes]
+
+
+   def setDelayTime(self, delayTime):
+      """ Sets delay time. """
+
+      # make input value is appropriate
+      if delayTime < 0:
+
+         raise ValueError("Delay time must 0 or greater (in milliseconds).")
+
+      # all well, so update
+      self.delayTime = delayTime
+
+
+   def getDelayTime(self):
+      """ Returns delay time. """
+
+      return self.delayTime
+
+
+   def setSustainVolume(self, sustainVolume):
+      """ Sets sustain volume. """
+
+      # make input value is appropriate
+      if sustainVolume < 0.0 or sustainVolume > 1.0:
+
+         raise ValueError("Sustain volume must be between 0.0 and 1.0.")
+
+      # all well, so update
+      self.sustainVolume = sustainVolume
+
+
+   def getSustainVolume(self):
+      """ Returns sustain volume. """
+
+      return self.sustainVolume
+
+
+   def setReleaseTime(self, releaseTime):
+      """ Sets release time. """
+
+      # make input value is appropriate
+      if releaseTime < 0:
+
+         raise ValueError("Release time must 0 or greater (in milliseconds).")
+
+      # all well, so update
+      self.releaseTime = releaseTime
+
+
+   def getReleaseTime(self):
+      """ Returns release time. """
+
+      return self.releaseTime
+
+
+   def performAttackDelaySustain(self, audioSample, volume, voice):
+      """ Applies the beginning of the envelope to the given voice of the provided audio sample.  This involves setting up appropriate timers
+          to adjust volume, at appropriate times, as dictated by the envelope settings.
+      """
+
+      # NOTE: In order to allow the same envelope to be re-used by different audio samples, we place inside the audio sample
+      #       a dictionary of timers, indexed by voice.  This way different audio samples will not compete with each other, if they are all
+      #       using the same envelope.
+      #
+      # Each voice has its own list of timers - implementing the envelope, while it is sounding
+      # This way, we can stop these timers, if the voice sounds less time than what the envelope - not an error (we will try and do our best)
+
+      # initialize envelope timers for this audio sample
+      if "envelopeTimers" not in dir(audioSample):   # is this the first time we see this audio sample?
+
+         audioSample.envelopeTimers = {}                # yes, so initiliaze dictionary of envelope timers
+
+      # now, we have a dictionary of envelope timers
+
+      # next, initiliaze list of timers for this voice (we may assume that none exists...)
+      audioSample.envelopeTimers[voice] = []
+
+      # set initial volume to zero
+      audioSample.setVolume(volume = 0, delay = 2, voice = voice)
+
+      # initialize variables
+      maxVolume = volume   # audio sample's requested volume... everything will be adjusted relative to that
+      nextTime  = 0        # next time to begin volume adjustment - start at beginning of sound
+
+      # schedule attack timers
+      for attackTime, attackVolume in zip(self.attackTimes, self.attackVolumes):
+
+         # adjust volume appropriately
+         volume = int(maxVolume * attackVolume)   # attackVolume ranges between 0.0 and 1.0, so we treat it as relative factor
+
+         # schedule volume change over this attack time
+         # NOTE: attackTime indicates how long this volume change should take!!!
+         timer = Timer2(nextTime, audioSample.setVolume, [volume, attackTime, voice], False)
+         #print "attack set - volume, delay, voice =", volume, nextTime, voice #***
+
+         # remember timer
+         audioSample.envelopeTimers[voice].append( timer )
+
+         # advance time
+         nextTime = nextTime + attackTime
+
+      # now, all attack timers have been created
+
+      # next, create timer to handle delay and sustain setting
+      volume   = int(maxVolume * self.sustainVolume)   # sustainVolume ranges between 0.0 and 1.0, so we treat it as relative factor
+
+      # schedule volume change over delay time
+      # NOTE: delay time indicates how long this volume change should take!!!
+      timer = Timer2(nextTime, audioSample.setVolume, [volume, self.delayTime, voice], False)
+      #print "delay set - volume, voice =", volume, voice #***
+
+      # remember timer
+      audioSample.envelopeTimers[voice].append( timer )
+
+      # beginning of envelope has been set up, so start timers to make things happen
+      for timer in audioSample.envelopeTimers[voice]:
+         timer.start()
+
+      # done!!!
+
+
+   def performReleaseAndStop(self, audioSample, voice):
+      """ Applies the release time (fade out) to the given voice of the provided audioSample. """
+
+      # stop any remaining timers, and empty list
+      for timer in audioSample.envelopeTimers[voice]:
+         timer.stop()
+
+      # empty list of timers - they are not needed anymore (clean up for next use...)
+      del audioSample.envelopeTimers[voice]
+
+      # turn volume down to zero, slowly, over release time milliseconds
+      audioSample.setVolume(volume = 0, delay = self.releaseTime, voice = voice)
+      #print "release set - volume, voice =", 0, voice #***
+
+      # and schedule sound to stop, after volume has been turned down completely
+      someMoreTime = 5   # to give a little extra time for things to happen (just in case) - in milliseconds (avoids clicking...)
+      timer = Timer2(self.releaseTime + someMoreTime, audioSample.stop, [voice], False)
+      timer.start()
+
+      # done!!!
+
+
 def _cleanupAudioSamples():
    """Stops and closes all active AudioSample players registered with atexit."""
    # iterate over a copy because sample.__del__() will modify _activeAudioSamples

CreativePython/_RealtimeAudioPlayer.py → _RealtimeAudioPlayer.py

@@ -7,7 +7,9 @@
 # [LICENSING GOES HERE]
 #
 #######################################################################################
-#
+# TODO:
+# - fade in/out logic is incomplete. We can probably remove it to avoid overhead.
+#   Thought it might be nice to prevent popping sounds.
 #
 #######################################################################################
 
@@ -16,7 +18,6 @@ import soundfile as sf    # for audio file reading
 import numpy as np        # for array operations
 import os                 # for file path operations
 import math               # for logarithmic calculations in pitch/frequency conversions
-import time               # for timing operations
 
 # helper functions
 def noteToFreq(pitch):
@@ -88,12 +89,12 @@ class _RealtimeAudioPlayer:
          self.baseFrequency = noteToFreq(self.basePitch) # default 440 Hz
 
       # fades (master)
-      self.fadeInDurationMs = 30
+      self.fadeInDurationMs = 20
       self.fadeInTotalFrames = max(1, int(self.sampleRate * (self.fadeInDurationMs / 1000.0)))
       self.fadeInFramesProcessed = 0
       self.isApplyingFadeIn = False
 
-      self.fadeOutDurationMs = 50
+      self.fadeOutDurationMs = 30
       self.fadeOutTotalFrames = max(1, int(self.sampleRate * (self.fadeOutDurationMs / 1000.0)))
       self.fadeOutFramesProcessed = 0
       self.isApplyingFadeOut = False
@@ -434,7 +435,7 @@ class _RealtimeAudioPlayer:
          # self.playbackPosition is advanced by self.rateFactor. If rateFactor is 1.0, it moves one sample forward.
          # If rateFactor is 0.5, it effectively plays at half speed (each source sample is held for two output samples, due to interpolation).
          # If rateFactor is 2.0, it plays at double speed (skipping source samples, with interpolation filling the gaps).
-         self.playbackPosition += self.rateFactor # RESTORED - No more * 0.5 hack
+         self.playbackPosition += self.rateFactor
 
          # 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
@@ -610,10 +611,10 @@ class _RealtimeAudioPlayer:
 
             self.sdStream = sd.OutputStream(
                samplerate=self.sampleRate,
-                  blocksize=self.chunkSize,
-                  channels=self.numChannels,
-                  callback=self.audioCallback,
-                  finished_callback=self.onPlaybackFinished
+               blocksize=self.chunkSize,
+               channels=self.numChannels,
+               callback=self.audioCallback,
+               finished_callback=self.onPlaybackFinished
             )
             self.sdStream.start()
             self.isPlaying = True
@@ -669,6 +670,7 @@ class _RealtimeAudioPlayer:
                else: print(f"Error closing PyAudio stream: {pae}")
             except Exception as e: print(f"Generic error closing PyAudio stream: {e}")
             self.sdStream = None
+
          self.isPlaying = False # confirm state
          self.targetEndSourceFrame = -1.0 # ensure reset if stopped externally
          self.playDurationSourceFrames = -1.0 # ensure reset
@@ -679,6 +681,7 @@ class _RealtimeAudioPlayer:
          self.loopsPerformed = 0
          return
 
+      # if we want to skip the nice fade-out for immediacy
       if immediate:
          self.isPlaying = False # signal callback to stop producing audio
          self.isApplyingFadeIn = False # cancel any ongoing fade-in
@@ -704,12 +707,14 @@ class _RealtimeAudioPlayer:
                print(f"Error during immediate stream stop/close: {e}")
             finally:
                self.sdStream = None # discard stream instance
+
          self.targetEndSourceFrame = -1.0
          self.playDurationSourceFrames = -1.0
          self.loopRegionStartFrame = 0.0
          self.loopRegionEndFrame = -1.0
          self.loopCountTarget = -1 if self.looping else 0
          self.loopsPerformed = 0
+
       else: # gradual stop (fade out)
          if self.isPlaying or self.isApplyingFadeIn: # only start a fade-out if actually playing or was about to start
             self.isApplyingFadeIn = False # stop any fade-in
@@ -742,7 +747,7 @@ class _RealtimeAudioPlayer:
             else:
                print(f"PortAudioError during stream stop/close: {pae}")
                # raise # Optionally re-raise if it's a different PortAudio error
-            print(f"Generic error during PortAudio stream stop/close: {e}")
+            print(f"Generic error during PortAudio stream stop/close: {pae}")
             # raise # Optionally re-raise
          finally:
             self.sdStream = None

creativepython-0.0.2.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: CreativePython
+Version: 0.0.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
+        
+        Copyright (c) 2025 Dr. Bill Manaris
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://jythonmusic.me
+Keywords: audio,midi,learning,algorithmic art,algoart
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# CreativePython
+
+CreativePython is a Python-based software environment for developing algorithmic art projects.  It mirrors the [JythonMusic API](https://jythonmusic.me/api-reference/).
+
+This package is still under development.
+
+---
+
+## Quick Install
+
+Download the [CreativePython Install Scripts](https://www.dropbox.com/scl/fo/if4jt56r9noqgj47rk2cq/AFRANez_l8BmKUU19-GAbh4?rlkey=uws2jof8hq2zpj0oke0rt7886&dl=1)
+
+### Windows 
+  1. Right-click `windows_setup.bat` → **Run as Administrator** (it will open PowerShell and run).  
+  2. Follow any prompts and let it finish.
+
+### macOS 
+  1. Control-click `mac_setup.command` → **Open** (it will open Terminal and run).
+  2. Follow any prompts and let it finish.
+
+---
+
+## Custom Installation
+
+See "Advanced Installation" in [INSTALL.md](https://www.dropbox.com/scl/fi/us1j6im3ef67lzyfvq6ub/INSTALL.md?rlkey=fu9yjzj1hk11p6wgmhsc27s8y&dl=0).

creativepython-0.0.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+AudioSample.py,sha256=oI3C-Y4ECZnyu3W2vV96BlRs6HrKZYtqSn6bgtDvgVU,45217
+_RealtimeAudioPlayer.py,sha256=bbH_R69yrGulkAV1J2apQzGS_jqADQhOenQNFapif4k,40138
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+creativepython_setup.py,sha256=NRi2_MaoeV1w8QOyWXan-VpIEJR0yTqTbBeY-SDfryE,3344
+gui.py,sha256=gx0RDyh-5xF4KFh0F4G-V89ESc1Jl_UlmqUi0W7WD8w,130358
+image.py,sha256=TEFjfqL-EikGlcMcj2QlHqwkEHaDp6oGAK2Vm--1dEs,2243
+midi.py,sha256=sFJ8s--YYWJE8v9YHtW7bReyyaOd6eks4A9IVVyAFRE,40068
+music.py,sha256=y4dNaW6SSkcz-dA3TIy5dm3w5DEuaTy-wive_yRRBkA,173577
+osc.py,sha256=EhYo9DtGax8WQe1vD30xzdkRX1GJu65b1AkZiSmPeQY,16013
+timer.py,sha256=bMBbdu3NtnmWFxcykiXdTBGK4J3QDEzPp-Nyb3OJzPs,22470
+creativepython-0.0.2.dist-info/licenses/LICENSE,sha256=1hbJHc1vxY4vAasDE4CMC4wDH91CBz5B-rgfujDntTw,1073
+creativepython-0.0.2.dist-info/METADATA,sha256=DwQ1P5R5YIc41IhovuWcDdT4zcwfNvPyVWSpn7D9a40,2865
+creativepython-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+creativepython-0.0.2.dist-info/entry_points.txt,sha256=iYj4CILkX4SebZA63f7dvmz0up_xoTOUzgNifR6O1Pw,94
+creativepython-0.0.2.dist-info/top_level.txt,sha256=S4p4nuCIv0l-lT3yPofgQ-Rf2QJrbZZKEqBGi4imI48,94
+creativepython-0.0.2.dist-info/RECORD,,

creativepython-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cp-setup = creativepython_setup:run
+cp-test = creativepython_setup:playNote

creativepython-0.0.2.dist-info/top_level.txt

@@ -0,0 +1,10 @@
+AudioSample
+_RealtimeAudioPlayer
+__init__
+creativepython_setup
+gui
+image
+midi
+music
+osc
+timer

creativepython_setup.py

@@ -0,0 +1,101 @@
+### SOUNDFONT DOWNLOAD HELPERS
+
+from __future__ import annotations
+from pathlib import Path
+from platformdirs import user_data_dir
+
+APP = "CreativePython"
+ORG = "CofC"
+
+SOUNDFONT_NAME = "default.sf2"
+CACHE_DIR = Path(user_data_dir(APP, ORG)) / "SoundFonts"
+SOUNDFONT_PATH = CACHE_DIR / SOUNDFONT_NAME
+
+SF2_URL = "https://www.dropbox.com/s/xixtvox70lna6m2/FluidR3%20GM2-2.SF2?dl=1"
+SF2_SHA256 = "2ae766ab5c5deb6f7fffacd6316ec9f3699998cce821df3163e7b10a78a64066"
+
+def find_soundfont(explicit: str | None = None) -> Path | None:
+   """
+   Finds a soundfont 'default.sf2' in the cache, and returns its location.
+   explicit can be another path that may have the soundfont needed.
+   """
+   import os
+
+   candidates = []
+   if explicit:
+      candidates.append(Path(explicit))
+   env = os.getenv("CREATIVEPYTHON_SOUNDFONT")
+   if env:
+      candidates.append(Path(env))
+   candidates += [SOUNDFONT_PATH, Path.home() / "SoundFonts" / SOUNDFONT_NAME]
+   for c in candidates:
+      if c and c.exists():
+         return c
+   return None
+
+def download_soundfont(dest: Path = SOUNDFONT_PATH) -> Path:
+   """Downloads a default soundfont and saves it to the user's cache."""
+   from pooch import retrieve, Unzip
+   dest.parent.mkdir(parents=True, exist_ok=True)
+   p = retrieve(url=SF2_URL, known_hash=f"sha256:{SF2_SHA256}", progressbar=True, fname=dest.name, path=str(dest.parent))
+   return Path(p)
+
+
+
+### AUTOMATIC CHECK METHODS
+
+def run():
+   import shutil, sys, os
+   missing = []
+
+   # Check for soundfont file
+   sf = find_soundfont()
+
+   # Attempt to download missing soundfont
+   if not sf:
+      print("CreativePython setup warning: No soundfont found.")
+      auto = os.getenv("CP_AUTO_DOWNLOAD") == "1"
+      if auto or input("Download the default soundfont now? [Y/n] ").strip().lower() in ("", "y", "yes"):
+         path = download_soundfont()
+         print(f"Downloaded to: {path}")
+      else:
+         print(f"\nPlace your .sf2 soundfont at:\n   {SOUNDFONT_PATH}\nOr set CREATIVEPYTHON_SOUNDFONT to its location in your PATH.")
+         print("\n(see https://pypi.org/project/CreativePython/ for more details)")
+
+
+   # Check for required installations
+   if not shutil.which("ffmpeg"):
+      missing.append("ffmpeg")
+
+   if not shutil.which("fluidsynth"):
+      missing.append("FluidSynth")
+   
+   if not shutil.which("portaudio"):
+      missing.append("PortAudio")
+
+   # Warn user about missing requirements
+   if missing:
+      print("\nCreativePython setup warning:")
+      for req in missing:
+         print(f"   - {req} is not installed.")
+      
+      if sys.platform.startswith("darwin"):
+         print("\nOn macOS, run:\n   brew install portaudio fluidsynth ffmpeg")
+      elif sys.platform.startswith("win"):
+         print("\nOn Windows, install missing packages from developers, or run windows_setup.bat")
+      else:
+         print("\nOn Linux, install missing packages with your package manager (apt, dnf, etc.)")
+
+      print("\n(see https://pypi.org/project/CreativePython/ for more details)")
+
+   return len(missing) == 0
+
+
+def playNote():
+   ready = run()  # check for installation dependencies
+
+   if ready:
+      from music import Note, Play, C4, HN  # can't use * within function, so naming needed pieces
+
+      note = Note(C4, HN)        # create a middle C half note
+      Play.midi(note)            # and play it!