CreativePython 0.0.3__py3-none-any.whl → 0.1.1__py3-none-any.whl

CreativePython/_soundfont.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+from platformdirs import user_data_dir
+from pooch import retrieve
+import shutil, sys, os
+
+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"
+
+##### SOUNDFONTS #####
+
+def _soundfontPath():
+   """Expose the intended soundfont path as a method."""
+   return SOUNDFONT_PATH
+
+def _findSoundfont(candidate=None):
+   """
+   Finds a soundfont 'default.sf2' and returns its location.
+   'candidate' can be another path containing the soundfont.
+   """
+   candidates = []
+   soundfontPath = None
+
+   # path as argument?
+   if candidate:
+      candidates.append(Path(candidate))
+   
+   # path as environment variable?
+   env = os.getenv("CREATIVEPYTHON_SOUNDFONT")
+   if env:
+      candidates.append(Path(env))
+
+   # default soundfont location
+   candidates+= [SOUNDFONT_PATH, Path.home() / "SoundFonts" / SOUNDFONT_NAME]
+
+   # find first valid candidate
+   i = 0
+   while soundfontPath is None and i < len(candidates):
+      c = candidates[i]
+      if c and c.exists():
+         soundfontPath = str(c)
+
+   return soundfontPath
+
+
+def _downloadSoundfont(destination=SOUNDFONT_PATH):
+   """
+   Downloads FluidR3 GM2-2 to given destination as 'default.sf2'
+   """
+   # create parent directory
+   destination.parent.mkdir(parents=True, exist_ok=True)
+   # download soundfont
+   path = retrieve(
+      url=SF2_URL,
+      known_hash=f"sha256:{SF2_SHA256}",
+      progressbar=True,
+      fname=destination.name,
+      path=str(destination.parent)
+   )
+   return path

CreativePython/examples/ArvoPart.CantusInMemoriam.py

@@ -0,0 +1,76 @@
+# ArvoPart.CantusInMemoriam.py
+#
+# Recreates a variation of Arvo Part's "Cantus in Memoriam Benjamin
+# Britten" (1977) for string orchestra and bell, using Mod functions.
+ 
+from music import *
+ 
+# musical parameters
+repetitions = 2   # length of piece
+tempo = 112       # tempo of piece
+bar = WN+HN       # length of a measure
+ 
+# create musical data structure
+cantusScore = Score("Cantus in Memoriam Benjamin Britten", tempo)
+ 
+bellPart = Part(TUBULAR_BELLS, 0)
+violinPart = Part(VIOLIN, 1)
+ 
+# bell
+bellPitches   = [REST,  A4,    REST, REST,  A4,    REST, REST,  A4]
+bellDurations = [bar/2, bar/2, bar,  bar/2, bar/2, bar,  bar/2, bar/2]
+ 
+bellPhrase = Phrase(0.0)
+bellPhrase.addNoteList(bellPitches, bellDurations)
+bellPart.addPhrase(bellPhrase)
+ 
+# violin - define descending aeolian scale and rhythms
+pitches   = [A5, G5, F5,  E5,  D5,  C5,  B4,  A4]
+durations = [HN, QN, HN, QN, HN, QN, HN, QN]
+ 
+# violin 1
+violin1Phrase = Phrase(bar * 6.5)  # start after 6 and 1/2 measures
+violin1Phrase.addNoteList(pitches, durations)
+ 
+# violin 2
+violin2Phrase = violin1Phrase.copy()
+violin2Phrase.setStartTime(bar * 7.0)  # start after 7 measures
+Mod.elongate(violin2Phrase, 2.0)       # double durations
+Mod.transpose(violin2Phrase, -12)      # an octave lower
+ 
+# violin 3
+violin3Phrase = violin2Phrase.copy()
+violin3Phrase.setStartTime(bar * 8.0)  # start after 8 measures
+Mod.elongate(violin3Phrase, 2.0)       # double durations
+Mod.transpose(violin3Phrase, -12)      # an octave lower
+ 
+# violin 4
+violin4Phrase = violin3Phrase.copy()
+violin4Phrase.setStartTime(bar * 10.0) # start after 10 measures
+Mod.elongate(violin4Phrase, 2.0)       # double durations
+Mod.transpose(violin4Phrase, -12)      # an octave lower
+ 
+# repeat phrases enough times
+Mod.repeat(violin1Phrase, 8 * repetitions)
+Mod.repeat(violin2Phrase, 4 * repetitions)
+Mod.repeat(violin3Phrase, 2 * repetitions)
+Mod.repeat(violin4Phrase, repetitions)
+ 
+# violin part
+violinPart.addPhrase(violin1Phrase)
+violinPart.addPhrase(violin2Phrase)
+violinPart.addPhrase(violin3Phrase)
+violinPart.addPhrase(violin4Phrase)
+ 
+# score
+cantusScore.addPart(bellPart)
+cantusScore.addPart(violinPart)
+ 
+# fade in, and fade out
+Mod.fadeIn(cantusScore, WN)
+Mod.fadeOut(cantusScore, WN * 12)
+ 
+# view, play, and write
+View.sketch(cantusScore)
+Play.midi(cantusScore)
+Write.midi (cantusScore, "ArvoPart.CantusInMemoriam.mid")

CreativePython/examples/ConcretPH_Xenakis.py

@@ -0,0 +1,41 @@
+# ConcretPH_Xenakis.py
+#
+# A short example which generates a random cloud texture
+# inspired by Iannis Xenakis's 'Concret PH' composition
+#
+# see http://en.wikipedia.org/wiki/Concret_PH
+ 
+from music import *
+from random import *
+ 
+# constants for controlling musical parameters
+cloudWidth = 64          # length of piece (in quarter notes)
+cloudDensity = 23.44     # how dense the cloud may be
+particleDuration = 0.2   # how long each sound particle may be
+numParticles = int(cloudDensity * cloudWidth)   # how many particles
+ 
+part = Part(BREATHNOISE)
+ 
+# make particles (notes) and add them to cloud (part)
+for i in range(numParticles):
+ 
+   # create note with random attributes
+   pitch = randint(0, 127)     # pick from 0 to 127
+   duration = random() * particleDuration # 0 to particleDuration
+   dynamic = randint(0, 127)   # pick from silent to loud
+   panning = random()          # pick from left to right
+   note = Note(pitch, duration, dynamic, panning)   # create note
+ 
+   # now, place it somewhere in the cloud (time continuum)
+   startTime = random() * cloudWidth    # pick from 0 to end of piece
+   phrase = Phrase(startTime)           # create phrase with this start time
+   phrase.addNote(note)                 # add the above note
+   part.addPhrase(phrase)               # and add both to the part
+# now, all notes have been created
+ 
+# add some elegance to the end
+Mod.fadeOut(part, 20)
+ 
+View.show(part)
+Play.midi(part)
+Write.midi(part, "ConcretPh.mid")

CreativePython/examples/DeepPurple.SmokeOnTheWater.py

@@ -0,0 +1,67 @@
+# DeepPurple.SmokeOnTheWater.py
+#
+# Demonstrates how to combine melodic lines, chords, and
+# percussion.  This is based on the intro of "Smoke On the Water" 
+# by Deep Purple.
+ 
+from music import *
+ 
+##### define the data structure
+score  = Score("Deep Purple, Smoke On The Water", 110)  # 110 bpm
+ 
+guitarPart = Part(OVERDRIVE_GUITAR, 0)
+bassPart = Part(ELECTRIC_BASS, 1)
+drumPart = Part(0, 9)    # using MIDI channel 9 (percussion)
+ 
+guitarPhrase1 = Phrase(0.0)   # guitar opening melody
+guitarPhrase2 = Phrase(32.0)  # guitar opening melody an octave lower
+bassPhrase = Phrase(64.0)     # bass melody
+drumPhrase = Phrase(96.0)     # drum pattern
+ 
+##### create musical data
+# guitar opening melody (16QN = 4 measures)
+guitarPitches   = [G2, AS2, C3,  G2, AS2, CS3, C3, G2, AS2, C3,  AS2, 
+                    G2]    
+guitarDurations = [QN, QN,  DQN, QN, QN,  EN,  HN, QN, QN,  DQN, QN,  
+                    DHN+EN]
+guitarPhrase1.addNoteList(guitarPitches, guitarDurations)
+ 
+# create a power-chord sound by repeating the melody an octave lower
+guitarPhrase2.addNoteList(guitarPitches, guitarDurations)
+Mod.transpose(guitarPhrase2, -12)
+ 
+# bass melody (32EN = 4 measures)
+bassPitches1   = [G2, G2, G2, G2, G2, G2, G2, G2, G2, G2, 
+                  G2, G2, G2, G2, G2, G2, G2, G2]
+bassDurations1 = [EN, EN, EN, EN, EN, EN, EN, EN, EN, EN, 
+                  EN, EN, EN, EN, EN, EN, EN, EN]
+bassPitches2   = [AS2, AS2, C3, C3, C3, AS2, AS2, G2, G2, 
+                  G2, G2, G2, G2, G2]
+bassDurations2 = [EN,  EN,  EN, EN, EN, EN,  EN,  EN, EN, 
+                  EN, EN, EN, EN, EN]
+bassPhrase.addNoteList(bassPitches1, bassDurations1)
+bassPhrase.addNoteList(bassPitches2, bassDurations2)
+ 
+# snare drum pattern (2QN x 8 = 4 measures)
+drumPitches   = [REST, SNR] * 8
+drumDurations = [QN,   QN]  * 8
+drumPhrase.addNoteList(drumPitches, drumDurations)
+ 
+##### repeat material as needed (based on how it's arranged in time)
+Mod.repeat(guitarPhrase1, 8)
+Mod.repeat(guitarPhrase2, 6)
+Mod.repeat(bassPhrase, 4)
+Mod.repeat(drumPhrase, 2)
+ 
+##### combine musical material
+guitarPart.addPhrase(guitarPhrase1)
+guitarPart.addPhrase(guitarPhrase2)
+bassPart.addPhrase(bassPhrase)
+drumPart.addPhrase(drumPhrase)
+score.addPart(guitarPart)
+score.addPart(bassPart)
+score.addPart(drumPart)
+ 
+##### play and write score to a MIDI file
+Play.midi(score)
+Write.midi(score, "DeepPurple.SmokeOnTheWater.mid")

CreativePython/examples/JS_Bach.Canon.TriasHarmonica.BWV1072.py

@@ -0,0 +1,77 @@
+# JS_Bach.Canon.TriasHarmonica.BWV1072.py
+#
+# This program creates J.S. Bach's 'Trias Harmonica' BWV 1072 canon.
+#
+# This canon is constructed using two parts (choirs), each consisting
+# of four voices. The first part's voices use the original theme,
+# each separated by a half-note delay. The second part's voices use
+# the inverted theme delayed by a quarter note, each separated by
+# a half-note delay.
+#
+ 
+from music import *
+ 
+# define the theme (for choir 1)
+pitches1   = [C4,  D4, E4,  F4, G4,  F4, E4,  D4]
+durations1 = [DQN, EN, DQN, EN, DQN, EN, DQN, EN]
+ 
+# define the inverted theme (for choir 2)
+pitches2   = [G4,  F4, E4,  D4, C4,  D4, E4,  F4]
+durations2 = [DQN, EN, DQN, EN, DQN, EN, DQN, EN]
+ 
+# how many times to repeat the theme
+times = 8
+ 
+# choir 1 - 4 voices separated by half note
+choir1 = Part()
+ 
+voice1 = Phrase(0.0)
+voice1.addNoteList(pitches1, durations1)
+Mod.repeat(voice1, times)           # repeat a number of times
+voice1.addNote(C4, DQN)             # add final note
+ 
+voice2 = voice1.copy()              # voice 2 is a copy of voice 1
+voice2.setStartTime(HN)             # separated by half note
+ 
+voice3 = voice1.copy()              # voice 3 is a copy of voice 1
+voice3.setStartTime(HN*2)           # separated by two half notes
+ 
+voice4 = voice1.copy()              # voice 4 is a copy of voice 1
+voice4.setStartTime(HN*3)           # separated by three half notes
+ 
+choir1.addPhrase(voice1)
+choir1.addPhrase(voice2)
+choir1.addPhrase(voice3)
+choir1.addPhrase(voice4)
+ 
+# choir 2 - 4 voices inverted, delayed by quarter note,
+# separated by a half note.
+choir2 = Part()
+ 
+voice5 = Phrase(QN)                 # delayed by quarter note
+voice5.addNoteList(pitches2, durations2)
+Mod.repeat(voice5, times)           # repeat a number of times
+voice5.addNote(G4, DQN)             # add final note
+ 
+voice6 = voice5.copy()              # voice 6 is a copy of voice 5
+voice6.setStartTime(QN + HN)        # separated by half note
+ 
+voice7 = voice5.copy()              # voice 7 is a copy of voice 5
+voice7.setStartTime(QN + HN*2)      # separated by two half notes
+ 
+voice8 = voice5.copy()              # voice 8 is a copy of voice 5
+voice8.setStartTime(QN + HN*3)      # separated by three half note
+ 
+choir2.addPhrase(voice5)
+choir2.addPhrase(voice6)
+choir2.addPhrase(voice7)
+choir2.addPhrase(voice8)
+ 
+# score
+canon = Score("J.S. Bach, Trias Harmonica (BWV 1072)", 100)
+canon.addPart(choir1)
+canon.addPart(choir2)
+ 
+# play score, and write it to a MIDI file
+Play.midi(canon)
+Write.midi(canon, "JS_Bach.Canon.TriasHarmonica.BWV1072.mid")

CreativePython/examples/JS_Bach.Canon_1.GoldbergGround.BWV1087.py

@@ -0,0 +1,39 @@
+# JS_Bach.Canon_1.GoldbergGround.BWV1087.py
+#
+# This program (re)creates J.S. Bach's Canon No. 1 of the Fourteen on
+# the Goldberg Ground.
+#
+# This canon is constructed using the Goldberg ground as the subject
+# (soggetto) combined with the retrograde of itself.
+#
+ 
+from music import *
+ 
+# how many times to repeat the theme
+times = 6
+ 
+# define the data structure
+score  = Score("J.S. Bach, Canon 1, Goldberg Ground (BWV1087)", 100)
+part   = Part()
+voice1 = Phrase(0.0)
+ 
+# create musical material (soggetto)
+pitches = [G3, F3, E3, D3, B2, C3, D3, G2]
+rhythms = [QN, QN, QN, QN, QN, QN, QN, QN]
+voice1.addNoteList(pitches, rhythms)
+ 
+# create 2nd voice
+voice2 = voice1.copy()
+Mod.retrograde(voice2)   # follower is retrograde of leader
+ 
+# combine musical material
+part.addPhrase(voice1)
+part.addPhrase(voice2)
+score.addPart(part)
+ 
+# repeat canon as desired
+Mod.repeat(score, times)
+ 
+# play score and write it to a MIDI file
+Play.midi(score)
+Write.midi(score, "JS_Bach.Canon_1.GoldbergGround.BWV1087.mid")

CreativePython/examples/Mozart.MusikalischesWurfelspiel.py

@@ -0,0 +1,101 @@
+# Mozart.MusikalischesWurfelspiel.py
+#
+# This program generates an excerpt of Mozart's "Musikalisches
+# Wurfelspiel" (aka Mozart's Dice Game). It demonstrates how
+# randomness may be sieved (harnessed) to produce aesthetic results.
+#
+# See Schwanauer, S, and D Levitt. 1993. Appendix, in Machine Models
+# of Music. Cambridge, MA: MIT Press, pp. 533-538.
+#
+# The original has 16 measures with 11 choices per measure.
+# This excerpt is a simplified form. In this excerpt,
+# musical material is selected from this matrix:
+#
+# I II III IV
+# 96 6 141 30
+# 32 17 158 5
+# 40
+#
+# Columns represent alternatives for a measure. The composer throws
+# dice to select an alternative (choice) from first column.
+# Then, connects it with the choice from second column, and so on.
+#
+ 
+from music import *
+from random import *
+ 
+# musical data structure
+walzerteil = Part() # contains a four-measure motif generated
+# randomly from the matrix above
+ 
+# measure 1 - create alternatives
+# choice 96
+pitches96 = [[C3, E5], C5, G4]
+durations96 = [EN, EN, EN]
+choice96 = Phrase()
+choice96.addNoteList(pitches96, durations96)
+ 
+# choice 32
+pitches32 = [[C3, E3, G4], C5, E5]
+durations32 = [EN, EN, EN]
+choice32 = Phrase()
+choice32.addNoteList(pitches32, durations32)
+ 
+# choice 40
+pitches40 = [[C3, E3, C5], B4, C5, E5, G4, C5]
+durations40 = [SN, SN, SN, SN, SN, SN]
+choice40 = Phrase()
+choice40.addNoteList(pitches40, durations40)
+ 
+# measure 2 - create alternatives
+# choice 6 (same as choice 32)
+choice6 = Phrase()
+choice6.addNoteList(pitches32, durations32)
+ 
+# choice 17
+pitches17 = [[E3, G3, C5], G4, C5, E5, G4, C5]
+durations17 = [SN, SN, SN, SN, SN, SN]
+choice17 = Phrase()
+choice17.addNoteList(pitches17, durations17)
+ 
+# measure 3 - create alternatives
+# choice 141
+pitches141 = [[B2, G3, D5], E5, F5, D5, [G2, C5], B4]
+durations141 = [SN, SN, SN, SN, SN, SN]
+choice141 = Phrase()
+choice141.addNoteList(pitches141, durations141)
+ 
+# choice 158
+pitches158 = [[G2, B4], D5, B4, A4, G4]
+durations158 = [EN, SN, SN, SN, SN]
+choice158 = Phrase()
+choice158.addNoteList(pitches158, durations158)
+ 
+# measure 4 - create alternatives
+# choice 30
+pitches30 = [[C5, G4, E4, C4, C2]]
+durations30 = [DQN]
+choice30 = Phrase()
+choice30.addNoteList(pitches30, durations30)
+ 
+# choice 5
+pitches5 = [[C2, C5, G4, E4, C4], [G2, B4], [C2, E4, C5]]
+durations5 = [SN, SN, QN]
+choice5 = Phrase()
+choice5.addNoteList(pitches5, durations5)
+ 
+# roll the dice!!!
+measure1 = choice([choice96, choice32, choice40])
+measure2 = choice([choice6, choice17])
+measure3 = choice([choice141, choice158])
+measure4 = choice([choice30, choice5])
+ 
+# connect the random measures into a waltz excerpt
+walzerteil.addPhrase(measure1)
+walzerteil.addPhrase(measure2)
+walzerteil.addPhrase(measure3)
+walzerteil.addPhrase(measure4)
+ 
+# view and play randomly generated waltz excerpt
+View.sketch(walzerteil)
+Play.midi(walzerteil)

CreativePython/examples/PierreCage.StructuresPourDeuxChances.py

@@ -0,0 +1,47 @@
+# PierreCage.StructuresPourDeuxChances.py
+#
+# This program (re)creates pieces similar to:
+#
+# Pierre Boulez, "Structures I for two pianos", and
+# John Cage, "Music of Changes, Book I".
+#
+# The piece generated consists of two parallel phrases containing
+# notes with random pitch and duration.
+#
+ 
+from music import *
+from random import *   # import random number generator
+ 
+numberOfNotes = 100    # how many notes in each parallel phrase
+ 
+##### define the data structure
+part = Part()          # create an empty part
+melody1 = Phrase(0.0)  # create phrase (at beginning of piece)
+melody2 = Phrase(0.0)  # create phrase (at beginning of piece)
+ 
+##### create musical data
+# create random notes for first melody
+for i in range(numberOfNotes):
+   pitch = randint(C1, C7)      # get random pitch between C1 and C6
+   duration = random() * 1.0    # get random duration (0.0 to 2.0)
+   dynamic = randint(PP, FFF)   # get random dynamic between P and FF
+   note = Note(pitch, duration, dynamic) # create note
+   melody1.addNote(note)        # and add it to the phrase
+# now, melody1 has been created
+ 
+# create random notes for second melody
+for i in range(numberOfNotes):
+   pitch = randint(C1, C7)      # get random pitch between C1 and C6
+   duration = random() * 1.0    # get random duration (0.0 to 2.0)
+   dynamic = randint(PP, FFF)   # get random dynamic between P and FF
+   note = Note(pitch, duration, dynamic) # create note
+   melody2.addNote(note)        # and add it to the phrase
+# now, melody2 has been created
+ 
+##### combine musical material
+part.addPhrase(melody1)
+part.addPhrase(melody2)
+ 
+##### play and write part to a MIDI file
+Play.midi(part)
+Write.midi(part, "Pierre Cage.Structures pour deux chances.mid")

CreativePython/examples/RGB_Display.py

@@ -0,0 +1,73 @@
+# RGB_Display.py
+#
+# Demonstrates how to use sliders to update values in real time (here, the
+# background color of the display).  It also uses labels to provide additional
+# feedback and visibility (by showing updated RGB values).
+#
+ 
+from gui import *
+ 
+# create display
+d = Display("RGB Display", 600, 400)
+ 
+# initialize RGB values (0-255)
+red   = 255
+green = 255
+blue  = 255
+ 
+# initialize display background to these RGB values
+d.setColor( Color(red, green, blue) )
+ 
+# create labels for the sliders with black text and white background
+labelRed   = Label(" R ", CENTER, Color.BLACK, Color.WHITE)
+labelGreen = Label(" G ", CENTER, Color.BLACK, Color.WHITE)
+labelBlue  = Label(" B ", CENTER, Color.BLACK, Color.WHITE)
+ 
+# add labels to display
+d.add(labelRed,   180, 132)
+d.add(labelGreen, 180, 182)
+d.add(labelBlue,  180, 232)
+ 
+# create labels for the sliders' values with black text and white background
+labelRedValue   = Label(" " + str(red) + " ",   CENTER, Color.BLACK, Color.WHITE)
+labelGreenValue = Label(" " + str(green) + " ", CENTER, Color.BLACK, Color.WHITE)
+labelBlueValue  = Label(" " + str(blue) + " ",  CENTER, Color.BLACK, Color.WHITE)
+ 
+# add labels for values to display
+d.add(labelRedValue,   400, 132)
+d.add(labelGreenValue, 400, 182)
+d.add(labelBlueValue,  400, 232)
+ 
+# define function to update red value
+def setRed(value):
+   global d, red, green, blue, labelRedValue 
+ 
+   red = value                                 # update red value
+   labelRedValue.setText(" " + str(red) + " ") # update red value label
+   d.setColor(Color(red, green, blue))         # update background color
+ 
+# define function to update green value
+def setGreen(value):
+   global d, red, green, blue, labelGreenValue  
+ 
+   green = value                                   # update green value
+   labelGreenValue.setText(" " + str(green) + " ") # update green value label
+   d.setColor(Color(red, green, blue))             # set background color
+ 
+# define function to update blue value
+def setBlue(value):
+   global d, red, green, blue, labelBlueValue  
+ 
+   blue = value                                  # update blue value
+   labelBlueValue.setText(" " + str(blue) + " ") # update blue value label
+   d.setColor(Color(red, green, blue))           # set background color
+ 
+# create sliders to set red, green, and blue values, respectively
+sliderRed   = Slider(HORIZONTAL, 0, 255, red, setRed)
+sliderGreen = Slider(HORIZONTAL, 0, 255, green, setGreen)
+sliderBlue  = Slider(HORIZONTAL, 0, 255, blue, setBlue)
+ 
+# add sliders to display
+d.add(sliderRed,   200, 125)
+d.add(sliderGreen, 200, 175)
+d.add(sliderBlue,  200, 225)

CreativePython/examples/TerryRiley.InC.py

@@ -0,0 +1,34 @@
+# TerryRiley.InC.py
+#
+# Live coding performance of Terry Riley's "In C".
+# See http://www.flagmusic.com/content/clips/inc.pdf
+ 
+from music import *
+from timer import *
+ 
+# redefine these notes at will
+pitches   = [E4, F4, E4]
+durations = [SN, SN, EN]
+ 
+# play above pitches and durations in a continuous loop
+def loopMusic():
+ 
+   global pitches, durations
+ 
+   # create phrase from current pitches and durations
+   theme = Phrase()
+   theme.addNoteList( pitches, durations )
+ 
+   # play it
+   Play.midi( theme )
+ 
+   # get duration of phrase in millisecs (assume 60BPM)
+   duration = int( theme.getBeatLength() * 1000 )
+ 
+   # create and start timer to call this function
+   # once recursively, after the elapsed duration
+   t = Timer( duration, loopMusic, [], False )
+   t.start()
+ 
+# start playing
+loopMusic()

CreativePython/examples/arpeggiator1.py

@@ -0,0 +1,30 @@
+# arpeggiator1.py
+#
+# A basic arpeggiator using absolute pitches.
+#
+ 
+from music import *
+ 
+arpeggioPattern = [C4, E4, G4, C5, G4, E4]   # arpeggiate the C chord
+duration = TN                                # duration for each note
+ 
+repetitions = input("How many times to repeat arpeggio: ")
+ 
+arpeggioPhrase = Phrase(0.0)        # phrase to store the arpeggio
+ 
+# create arpeggiated sequence of notes
+for pitch in arpeggioPattern:
+   n = Note(pitch, duration)    # create note with next pitch
+   arpeggioPhrase.addNote(n)    # and add it to phrase
+ 
+# now, the arpeggiation pattern has been created.
+ 
+# repeat it as many times requested
+Mod.repeat(arpeggioPhrase, repetitions)
+ 
+# add final note to complete arpeggio
+lastPitch = arpeggioPattern[0]      # use first pitch as last pitch
+n = Note(lastPitch, duration * 2)   # using longer duration
+arpeggioPhrase.addNote(n)           # add it
+ 
+Play.midi(arpeggioPhrase)

CreativePython/examples/arpeggiator2.py

@@ -0,0 +1,32 @@
+# arpeggiator2.py
+#
+# A basic arpeggiator using relative pitches.
+#
+ 
+from music import *
+ 
+arpeggioPattern = [0, 4, 7, 12, 7, 4]   # arpeggiate a major chord
+duration = TN                           # duration for each note
+ 
+rootPitch   = input("Enter root note (e.g., C4): ")
+repetitions = input("How many times to repeat arpeggio: ")
+ 
+arpeggioPhrase = Phrase(0.0)        # phrase to store the arpeggio
+ 
+# create arpeggiated sequence of notes
+for interval in arpeggioPattern:
+   pitch = rootPitch + interval # calculate absolute pitch
+   n = Note(pitch, duration)    # create note with next pitch
+   arpeggioPhrase.addNote(n)    # and add it to phrase
+ 
+# now, the arpeggiation pattern has been created.
+ 
+# repeat it as many times requested
+Mod.repeat(arpeggioPhrase, repetitions)
+ 
+# add final note to complete arpeggio
+lastPitch = rootPitch + arpeggioPattern[0]  # close with first pitch
+n = Note(lastPitch, duration * 4)   # but with longer duration
+arpeggioPhrase.addNote(n)           # add it
+ 
+Play.midi(arpeggioPhrase)