CreativePython 0.3.3__tar.gz → 0.3.5__tar.gz

{creativepython-0.3.3/src/CreativePython.egg-info → creativepython-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CreativePython
-Version: 0.3.3
+Version: 0.3.5
 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-0.3.3 → creativepython-0.3.5}/pyproject.toml

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

{creativepython-0.3.3 → creativepython-0.3.5/src/CreativePython.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CreativePython
-Version: 0.3.3
+Version: 0.3.5
 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-0.3.3 → creativepython-0.3.5}/src/CreativePython.egg-info/SOURCES.txt

@@ -20,7 +20,6 @@ src/CreativePython.egg-info/SOURCES.txt
 src/CreativePython.egg-info/dependency_links.txt
 src/CreativePython.egg-info/requires.txt
 src/CreativePython.egg-info/top_level.txt
-src/CreativePython/examples/.DS_Store
 src/CreativePython/examples/ArvoPart.CantusInMemoriam.py
 src/CreativePython/examples/ConcretPH_Xenakis.py
 src/CreativePython/examples/DeepPurple.SmokeOnTheWater.py
@@ -102,9 +101,10 @@ src/CreativePython/examples/themeAndVariations.py
 src/CreativePython/examples/throwingDice.py
 src/CreativePython/examples/windChimes.py
 src/CreativePython/examples/zipfMetrics.py
-src/CreativePython/resources/.DS_Store
 src/CreativePython/resources/550973__luizguilherme_a__clean-guitarr-riff.mp3
 src/CreativePython/resources/chopper.jpg
 src/CreativePython/resources/de-brazzas-monkey.jpg
 src/bin/libportaudio.2.dylib
+tests/testAnimate.py
+tests/testPeer.py
 tests/test_keyEvent.py

{creativepython-0.3.3 → creativepython-0.3.5}/src/gui.py

@@ -1242,13 +1242,13 @@ class Display(Interactable):
       """
       Returns the display's canvas width (in pixels).
       """
-      return self._scene.width()
+      return int(self._scene.width())
 
    def getHeight(self):
       """
       Returns the display's canvas height (in pixels).
       """
-      return self._scene.height()
+      return int(self._scene.height())
 
    def setSize(self, width, height):
       """
@@ -4212,6 +4212,86 @@ class Menu():
       self._qObject.setEnabled(False)
 
 
+#######################################################################################
+# Animation Engine
+#######################################################################################
+# animate() - this is a function to register functions that should be called repeatedly.  
+# Registered functions should expect zero parameters.  Also provided is setAnimationRate().  
+# The idea is to provide a simple way to animate things (be it visual, or other).  
+# This is basic functionality, inspired by MIT Processing's draw() function.  
+# Anything more involved can be easily created using a Timer.
+
+from timer import Timer2
+
+animationRate      = 60                     # 60 times per second
+animationInterval  = 1000 / animationRate   # convert to milliseconds
+
+if "_ANIMATIONFUNCTIONS_" not in globals():
+   _ANIMATIONFUNCTIONS_ = []  # claim global variable for animation functions
+
+def callAnimationFunctions():
+   """When timer goes off, we call this function, which calls all functions added to the animation list."""
+   global _ANIMATIONFUNCTIONS_
+
+   # call every function in animationFunctions list
+   for function in _ANIMATIONFUNCTIONS_:
+      function()   
+
+# animation engine is just a timer
+animationEngine = Timer2(
+   timeInterval=animationInterval,
+   function=callAnimationFunctions,
+   parameters=[],
+   repeat=True
+)
+
+animationEngine.start()  # start it
+
+
+def animate(function):
+   """Adds a function to be called repeatedly by the animation engine."""
+   global animationEngine
+
+   if callable(function):
+      _ANIMATIONFUNCTIONS_.append(function)  # add function to list of functions to call
+   else:
+      print(f"animate(): function '{function}' is not callable.")
+
+
+def setAnimationRate(frameRate=60):
+   """Set animation frame rate (frames per second)."""
+   global animationEngine
+
+   animationInterval  = 1000 / frameRate         # convert to milliseconds
+   animationEngine.setDelay(animationInterval)   # and set it
+
+
+def getAnimationRate():
+   """Returns animation frame rate (frames per second)."""
+   global animationEngine
+
+   animationInterval = animationEngine.getDelay()   # get delay in milliseconds
+   animationRate     = 1000 / animationInterval     # convert to times per second (rate)
+   return animationRate
+
+
+def __stopAnimationEngine__():
+   """Function to stop and clean-up animation engine."""
+   global animationEngine
+
+   animationEngine.stop()  # first, stop it
+   del animationEngine     # then, delete it 
+
+# # now, register function with JEM (if possible)
+# try:
+#     # if we are inside JEM, registerStopFunction() will be available
+#     registerStopFunction(__stopAnimationEngine__)   # tell JEM which function to call when the Stop button is pressed
+
+# except:  # otherwise (if we get an error), we are NOT inside JEM 
+#     pass    # so, do nothing.
+
+
+
 #######################################################################################
 # Test
 #######################################################################################

{creativepython-0.3.3 → creativepython-0.3.5}/src/midi.py

@@ -639,11 +639,17 @@ class MidiOut:
          noteID = (pitch, channel)                   # create an ID using pitch-channel pair
 
          # next, remove this noteID from the list, so that we may check for remaining instances
-         notesCurrentlyPlaying.remove(noteID)        # remove noteID
-         if noteID not in notesCurrentlyPlaying:     # is this last instance of note?
+         # check if this note is playing
+         if noteID in notesCurrentlyPlaying:
+            notesCurrentlyPlaying.remove(noteID)        # remove noteID
 
-            # yes, so turn it off!
-            self.sendMidiMessage(NOTE_OFF, channel, pitch, 0)
+            # only send note off if this was the last instance
+            if noteID not in notesCurrentlyPlaying:     # is this last instance of note?
+               # yes, so turn it off!
+               self.sendMidiMessage(NOTE_OFF, channel, pitch, 0)
+         else:
+            # attempting to turn off a note that is not currently playing
+            print(f"MidiOut.frequencyOff(): Attempting to turn off frequency {frequency} Hz (pitch {pitch}) on channel {channel}, which is not currently playing.")
       else:
          # frequency was outside expected range
          print(f"MidiOut.frequencyOff(): Invalid frequency {frequency}, expected frequency in Hz from 8.17 to 12600.0 (float).")

{creativepython-0.3.3 → creativepython-0.3.5}/src/music.py

@@ -125,7 +125,7 @@ MIDI_PITCHES = ["C_1", "CS_1", "D_1", "DS_1", "E_1", "F_1", "FS_1", "G_1", "GS_1
 #######################################################################################
 # MIDI rhythm/duration constants
 
-DWN  = DOTTED_WHOLE_NOTE          = 4.5
+DWN  = DOTTED_WHOLE_NOTE          = 6.0
 WN   = WHOLE_NOTE                 = 4.0
 DHN  = DOTTED_HALF_NOTE           = 3.0
 DDHN = DOUBLE_DOTTED_HALF_NOTE    = 3.5
@@ -536,9 +536,12 @@ def mapScale(value, minValue, maxValue, minResultValue, maxResultValue, scale=CH
           so pitchRow must contain offsets (from the root) between 0 and 11.
    """
    # check if value is within the specified range
-   if value < minValue or value > maxValue:
-      raise ValueError("value, " + str(value) + ", is outside the specified range, " \
-                                 + str(minValue) + " to " + str(maxValue) + ".")
+   # if value < minValue or value > maxValue:
+   #    raise ValueError("value, " + str(value) + ", is outside the specified range, " \
+   #                               + str(minValue) + " to " + str(maxValue) + ".")
+
+   # clamp value to specified range
+   value = min(maxValue, max(value, minValue))
 
    # check pitch row - it should contain offsets only from 0 to 11
    badOffsets = [offset for offset in scale if offset < 0 or offset > 11]
@@ -1917,7 +1920,7 @@ class Play:
                   # NOTE:  Below we use note length as opposed to duration (getLength() vs. getDuration())
                   # since note length gives us a more natural sounding note (with proper decay), whereas
                   # note duration captures the more formal (printed score) duration (which sounds unnatural).
-                  duration = int(note.getLength() * FACTOR)             # get note length (as oppposed to duration!) and convert to milliseconds
+                  duration = int(note.getLength() * FACTOR)   # convert to milliseconds
                   startTime = startTime + note.getDuration() * FACTOR   # update start time (in milliseconds)
                   velocity = note.getDynamic()
 
@@ -2341,7 +2344,7 @@ class Play:
                   # NOTE:  Below we use note length as opposed to duration (getLength() vs. getDuration())
                   # since note length gives us a more natural sounding note (with proper decay), whereas
                   # note duration captures the more formal (printed score) duration (which sounds unnatural).
-                  duration = int(note.getLength() * FACTOR)             # get note length (as oppposed to duration!) and convert to milliseconds
+                  duration = int(note.getLength() * FACTOR)   # convert to milliseconds
                   velocity = note.getDynamic()
 
                   # accumulate non-REST notes
@@ -2572,7 +2575,7 @@ class Play:
                   # NOTE:  Below we use note length as opposed to duration (getLength() vs. getDuration())
                   # since note length gives us a more natural sounding note (with proper decay), whereas
                   # note duration captures the more formal (printed score) duration (which sounds unnatural).
-                  duration = int(note.getLength() * FACTOR)             # get note length (as oppposed to duration!) and convert to milliseconds
+                  duration = int(note.getLength() * FACTOR)   # convert to milliseconds
                   velocity = note.getDynamic()
 
                   # accumulate non-REST notes
@@ -5399,11 +5402,12 @@ class Read:
             # part.setTitle(f"Track {trackIndex}") # Optional: name part by track index or name
 
             phrasesForPart = []
-            # stores the logical end time in beats for each phrase in phrasesForPart
-            phraseCurrentLogicalEndTimeBeats = []
+            # stores the logical end time for each phrase in phrasesForPart
+            phraseCurrentLogicalEndTime = []
 
             activeNotesOnTrack = {}      # key=(channel, pitch), value=list of (startTime_ticks, velocity)
             absoluteTimeTicksTrack = 0   # cumulative time in ticks for the current track
+            currentPanValue = 0.5   # track current pan (default = center, 0.0-1.0)
 
             for msg in track:
                absoluteTimeTicksTrack += msg.time
@@ -5420,14 +5424,40 @@ class Read:
                   score.setTimeSignature(msg.numerator, msg.denominator)
 
                elif msg.type == 'key_signature':
-                  # Placeholder for key signature handling if JMC constants for keys are defined
-                  # And a mapping from mido key string to key integer is available.
-                  # For now, we are skipping it as in the previous version.
-                  # score.setKeySignature(mido_key_to_jmusic_int(msg.key))
-                  # score.setKeyQuality(...) # Major/minor if discernible
-                  pass
+                  # Map mido key strings to (keySignature, keyQuality)
+                  # keySignature: num sharps (positive) or flats (negative)
+                  # keyQuality: 0 = Major, 1 = Minor
+                  midoKeySignatureMap = {
+                     'C': (0, 0), 'Am': (0, 1),
+                     'G': (1, 0), 'Em': (1, 1),
+                     'D': (2, 0), 'Bm': (2, 1),
+                     'A': (3, 0), 'F#m': (3, 1),
+                     'E': (4, 0), 'C#m': (4, 1),
+                     'B': (5, 0), 'G#m': (5, 1),
+                     'F#': (6, 0), 'D#m': (6, 1),
+                     'C#': (7, 0), 'A#m': (7, 1),
+                     'F': (-1, 0), 'Dm': (-1, 1),
+                     'Bb': (-2, 0), 'Gm': (-2, 1),
+                     'Eb': (-3, 0), 'Cm': (-3, 1),
+                     'Ab': (-4, 0), 'Fm': (-4, 1),
+                     'Db': (-5, 0), 'Bbm': (-5, 1),
+                     'Gb': (-6, 0), 'Ebm': (-6, 1),
+                     'Cb': (-7, 0), 'Abm': (-7, 1)
+                  }
+
+                  if msg.key in midoKeySignatureMap:
+                     signature, quality = midoKeySignatureMap[msg.key]
+                     score.setKeySignature(signature)
+                     score.setKeyQuality(quality)
+
+               elif msg.type == 'control_change':
+                  if msg.is_cc(7):   # volume controller
+                     part.setVolume(msg.value)   # 0-127, no conversion needed
+                  elif msg.is_cc(10):   # pan controller
+                     currentPanValue = msg.value / 127.0   # MIDI 0-127 -> float 0.0-1.0
 
                elif msg.type == 'note_on' and msg.velocity > 0:   # note on
+                  part.setChannel(msg.channel)
                   key = (msg.channel, msg.note)
                   if key not in activeNotesOnTrack:
                      activeNotesOnTrack[key] = []
@@ -5440,47 +5470,51 @@ class Read:
                      if not activeNotesOnTrack[key]:   # clean up if list is empty
                         del activeNotesOnTrack[key]
 
-                     noteStartTimeBeats = startTimeTicks / midiFile.ticks_per_beat
-                     noteEndTimeBeats = absoluteTimeTicksTrack / midiFile.ticks_per_beat
+                     noteStartTime = startTimeTicks / midiFile.ticks_per_beat
+                     noteEndTime = absoluteTimeTicksTrack / midiFile.ticks_per_beat
 
-                     if noteEndTimeBeats <= noteStartTimeBeats:
+                     if noteEndTime <= noteStartTime:
                         continue
 
-                     durationBeats = noteEndTimeBeats - noteStartTimeBeats
+                     duration = noteEndTime - noteStartTime
 
                      targetPhraseIndex = -1
                      for phraseIdx in range(len(phrasesForPart)):
                         # A phrase is suitable if this note starts at or after the phrase's current logical end time
                         # (with a small tolerance for notes that might slightly precede the 'official' end due to rounding)
                         # jMusic uses a 0.08 beat tolerance.
-                        if phraseCurrentLogicalEndTimeBeats[phraseIdx] <= noteStartTimeBeats + 0.08:
+                        if phraseCurrentLogicalEndTime[phraseIdx] <= noteStartTime + 0.08:
                            targetPhraseIndex = phraseIdx
                            break
 
                      # create new phrase if no suitable existing phrase found
                      if targetPhraseIndex == -1:
                         newPhrase = Phrase()
-                        newPhrase.setStartTime(noteStartTimeBeats)
+                        newPhrase.setStartTime(noteStartTime)
                         phrasesForPart.append(newPhrase)
-                        phraseCurrentLogicalEndTimeBeats.append(noteStartTimeBeats)
+                        phraseCurrentLogicalEndTime.append(noteStartTime)
                         targetPhraseIndex = len(phrasesForPart) - 1
 
                      # get reference to current phrase and its logical end time
                      currentSelectedPhrase = phrasesForPart[targetPhraseIndex]
-                     currentPhraseLogicalEnd = phraseCurrentLogicalEndTimeBeats[targetPhraseIndex]
+                     currentPhraseLogicalEnd = phraseCurrentLogicalEndTime[targetPhraseIndex]
 
                      # add rest if there's a gap between current phrase end and note start
-                     if noteStartTimeBeats > currentPhraseLogicalEnd:
-                        restDuration = noteStartTimeBeats - currentPhraseLogicalEnd
-                        if restDuration > 0.01:   # only add rest if gap is significant
+                     if noteStartTime > currentPhraseLogicalEnd:
+                        restDuration = noteStartTime - currentPhraseLogicalEnd
+
+                        # add explicit rest for gaps > 0.01 beats (ignore tiny gaps from MIDI timing jitter)
+                        if restDuration > 0.01:
                            restNote = Note(REST, restDuration)
                            currentSelectedPhrase.addNote(restNote)
-                           phraseCurrentLogicalEndTimeBeats[targetPhraseIndex] += restDuration
+                           phraseCurrentLogicalEndTime[targetPhraseIndex] += restDuration
 
                      # add the actual note and update phrase end time
-                     jmusicNote = Note(msg.note, durationBeats, velocity)
+                     # NOTE: preserve exact MIDI timing: set length = duration
+                     jmusicNote = Note(msg.note, duration, velocity, length=duration)
+                     jmusicNote.setPan(currentPanValue)   # apply current pan from CC 10
                      currentSelectedPhrase.addNote(jmusicNote)
-                     phraseCurrentLogicalEndTimeBeats[targetPhraseIndex] = noteEndTimeBeats
+                     phraseCurrentLogicalEndTime[targetPhraseIndex] = noteEndTime
 
             # End of message loop for track
             # Handle any notes still active at the end of the track (e.g., if no note_off)
@@ -5572,6 +5606,34 @@ class Write:
                                               denominator=denominator,
                                               time=0))
 
+         # add key signature to metadata track
+         # reverse mapping from (keySignature, keyQuality) to mido key strings
+         reverseKeySignatureMap = {
+            (0, 0): 'C', (0, 1): 'Am',
+            (1, 0): 'G', (1, 1): 'Em',
+            (2, 0): 'D', (2, 1): 'Bm',
+            (3, 0): 'A', (3, 1): 'F#m',
+            (4, 0): 'E', (4, 1): 'C#m',
+            (5, 0): 'B', (5, 1): 'G#m',
+            (6, 0): 'F#', (6, 1): 'D#m',
+            (7, 0): 'C#', (7, 1): 'A#m',
+            (-1, 0): 'F', (-1, 1): 'Dm',
+            (-2, 0): 'Bb', (-2, 1): 'Gm',
+            (-3, 0): 'Eb', (-3, 1): 'Cm',
+            (-4, 0): 'Ab', (-4, 1): 'Fm',
+            (-5, 0): 'Db', (-5, 1): 'Bbm',
+            (-6, 0): 'Gb', (-6, 1): 'Ebm',
+            (-7, 0): 'Cb', (-7, 1): 'Abm'
+         }
+
+         keySignature = score.getKeySignature()   # -7 to 7
+         keyQuality = score.getKeyQuality()   # 0=Major, 1=Minor
+         keyTuple = (keySignature, keyQuality)
+
+         if keyTuple in reverseKeySignatureMap:
+            midoKeyString = reverseKeySignatureMap[keyTuple]
+            metaTrack.append(mido.MetaMessage('key_signature', key=midoKeyString, time=0))
+
          # end of metadata track
          metaTrack.append(mido.MetaMessage('end_of_track', time=0))
 
@@ -5660,7 +5722,8 @@ class Write:
                   noteTicks = phraseStartTicks + int(noteStartTime * 480)
 
                   # calculate note duration in ticks
-                  durationTicks = int(note.getDuration() * 480)
+                  # NOTE: we use getDuration() to preserve the exact notated timing
+                  soundingTicks = int(note.getDuration() * 480)
 
                   # get note velocity (dynamic)
                   velocity = note.getDynamic()
@@ -5689,7 +5752,7 @@ class Write:
 
                   # create note_off event
                   events.append({
-                     'tick': noteTicks + durationTicks,
+                     'tick': noteTicks + soundingTicks,
                      'msg': mido.Message('note_off',
                                        note=pitch,
                                        velocity=0,

creativepython-0.3.5/tests/testAnimate.py

@@ -0,0 +1,11 @@
+from gui import *
+
+n = 0
+
+def testFunction():
+   global n
+   print(n)
+   n = n + 1
+
+setAnimationRate(1)
+animate(testFunction)

creativepython-0.3.5/tests/testPeer.py

@@ -0,0 +1,9 @@
+# localhost_udp_test.py
+import socket
+
+sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+sock.bind(("127.0.0.1", 57111))
+print("Listening on 127.0.0.1:57111")
+while True:
+    data, addr = sock.recvfrom(4096)
+    print("Received:", data, "from", addr)