CreativePython 0.3.5__tar.gz → 1.0.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CreativePython
-Version: 0.3.5
+Version: 1.0.0
 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
@@ -65,9 +65,7 @@ Requires-Dist: pooch>=1.8
 Requires-Dist: pypianoroll>=1.0
 Requires-Dist: verovio>=5.6.0
 Requires-Dist: pymusicxml>=0.5.6
-Provides-Extra: dev
-Requires-Dist: build; extra == "dev"
-Requires-Dist: twine; extra == "dev"
+Requires-Dist: pyinstaller>=6.16.0
 Dynamic: license-file
 
 # CreativePython

{creativepython-0.3.5 → creativepython-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "CreativePython"
-version = "0.3.5"
+version = "1.0.0"
 description = "A Python-based software environment for developing algorithmic art projects."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -33,12 +33,13 @@ dependencies = [
    "pooch>=1.8",
    "pypianoroll>=1.0",
    "verovio>=5.6.0",
-   "pymusicxml>=0.5.6"
+   "pymusicxml>=0.5.6",
+   "pyinstaller>=6.16.0"
 ]
 
 [tool.setuptools]
 package-dir = {"" = "src"}
-py-modules = ["gui", "image", "midi", "music", "osc", "timer", "iannix", "markov", "zipf", "_RealtimeAudioPlayer", "_notationRenderer"]
+py-modules = ["gui", "image", "midi", "music", "osc", "timer", "iannix", "markov", "zipf"]
 
 [tool.setuptools.packages.find]
 where = ["src"]
@@ -47,7 +48,4 @@ where = ["src"]
 "CreativePython" = ["bin/libportaudio.2.dylib"]
 
 [project.urls]
-Homepage = "https://jythonmusic.me"
-
-[project.optional-dependencies]
-dev = ["build", "twine"]
+Homepage = "https://jythonmusic.me"

{creativepython-0.3.5 → creativepython-1.0.0}/src/CreativePython/__init__.py

@@ -7,4 +7,4 @@ if platform.system() == "Darwin":
       with importlib.resources.path("CreativePython.bin", "libportaudio.2.dylib") as libpath:
          ctypes.CDLL(str(libpath))
    except Exception:
-      pass
+      pass

creativepython-1.0.0/src/CreativePython/nevmuse/Java-Comparison-Tests/advMetricRunner.pythonSurvey.py

@@ -0,0 +1,224 @@
+#######################################################################################################
+# advMetricRunner.jythonSurvey.py       Version 1.1     20-Sep-2025     Jimmy Cyganek, David Johnson, John Emerson,
+#                                                          Luca Pellicoro, Patrick Roos, Bill Manaris
+#######################################################################################################
+
+### Description: Runs metrics on a folder of MIDI files, these metrics are saved into a CSV file
+
+### 1.1 (Sep. 20, 2025) - Removed DurationDistanceMetric from Surveyor, as it returns innacurate measurements
+
+# import libraries
+import os
+import sys
+import unicodedata
+
+# add src to path if needed
+srcDir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+if srcDir not in sys.path:
+   sys.path.insert(0, srcDir)
+
+from music import *
+from ..Surveyor import Surveyor
+from ..metrics.simple import *   # import simple metrics
+
+
+#####
+# set MIDI file path
+midiFolderPath = "Bach AoF Fugues"
+
+# using os module, find everything in folder that ends in ".mid"
+folderFileNames = os.listdir(midiFolderPath)   # get filenames in folder (as strings)
+
+
+#####
+# keep only MIDI files
+midiFileNames = []
+for name in folderFileNames:   # iterate through all filenames
+
+   if name[-4:] == ".mid":     # is it a MIDI file?
+      midiFileNames.append(name)   # yes, so remember it
+
+# now, midiFileNames contains all the names of MIDI files in midiFolderPath
+
+
+#####
+# define metrics to apply (we only need to create them once - they will be reused for every MIDI file)
+metrics = [
+   PitchMetric(2),
+#   PitchDistanceMetric(2),
+   PitchDurationMetric(2),
+   PitchDurationQuantizedMetric(2),            # added Jan. 6 2010
+
+   ChromaticToneMetric(2),
+
+   DurationMetric(2),
+   DurationBigramMetric(2),
+#   DurationDistanceMetric(2),                  # added Sep. 30 2009
+
+   DurationQuantizedMetric(2),                 # added Jan. 6 2010
+   DurationQuantizedBigramMetric(2),           # added Jan. 7 2010
+   DurationQuantizedDistanceMetric(2),         # added Jan. 6 2010
+
+   ContourMelodyPitchMetric(2),                # added Jan. 7 2010
+   ContourMelodyDurationMetric(2),             # added Jan. 7 2010
+   ContourMelodyDurationQuantizedMetric(2),    # added Jan. 7 2010
+
+   ContourBasslinePitchMetric(2),              # added Jan. 7 2010
+   ContourBasslineDurationMetric(2),           # added Jan. 7 2010
+   ContourBasslineDurationQuantizedMetric(2),  # added Jan. 7 2010
+
+   MelodicIntervalMetric(2),
+   MelodicBigramMetric(2),
+   MelodicConsonanceMetric(2),
+
+   HarmonicIntervalMetric(2),
+   HarmonicBigramMetric(2),
+   HarmonicConsonanceMetric(2),
+
+   ChordMetric(2),
+   RestMetric(2)
+]
+
+
+#####
+# function to return metrics for a MIDI file
+def runMetrics(midiFilePath):
+
+   # load MIDI into  Score object
+   score = Score("Metric Score")
+   Read.midi(score, midiFilePath)
+
+   # initialize Surveyor and apply metrics to the score
+   quantum = 0.25
+   surveyor = Surveyor()
+   surveyor.survey(score, metrics, quantum)
+
+   # get measurements for each metric
+   measurements = []
+   for metric in metrics:   # iterate through each metric
+
+      # get measurement
+      measurement = metric.getMeasurement()
+      measurements.append(measurement)
+
+   #print measurements
+   return measurements
+
+#####
+# create a unique identifier for each piece - used as an attribute in Weka!!!
+index = 0   # initialize
+
+# function to create CSV file using list of measurements
+def writeCSVFile(measurements, midiFolderPath, midiFileName, csvfile):
+
+   global index           # used for index Weka attribute
+
+   index = index + 1      # create unique identifier for this piece
+
+   csvfile.write("\n")    # move down a row
+
+   # for each metric, get each measurement and add it to the corresponding column
+   for measurement in measurements:
+
+      values = measurement.valuesToArray()   # get attribute values for each metric
+
+      # get value of each measurement and write it to CSV file
+      for value in values:
+
+         csvfile.write(convertToASCII(value) + ",")   # write it!!
+
+   csvfile.write(convertToASCII(index) + ",")      # write index value to index column
+
+   # Caution: remove comma from filename - if any (since CSV files use comma as delimiter)
+   noCommaFileName = midiFileName.replace(",", "")
+
+   # write filename to the filename column (last column)
+   csvfile.write(convertToASCII(noCommaFileName))
+
+   # ***
+   print("Wrote row for", midiFileName)
+
+#####
+# function to remove non-ASCII characters
+def convertToASCII(string):
+
+   # ***
+   #try:
+   # convert input to unicode string (in Python 3, str is already unicode)
+   unicodeString = str(string)
+
+   # convert string to NFKD format (separate characters from accents - creates two characters from one)
+   nfkdString = unicodedata.normalize('NFKD', unicodeString)
+
+   # re-encode to ASCII - ignore non-ASCII characters (like accents or symbols)
+   asciiBytes = nfkdString.encode('ascii', 'ignore')
+
+   # decode back to string (Python 3 returns bytes from encode)
+   asciiString = asciiBytes.decode('ascii')
+
+   # return ASCII-only version of the string
+   return asciiString
+
+   #except:  # ***
+
+      # if there is no error, return as a string
+      #return str(string)
+
+
+##### Main #####
+
+# Goal: process all MIDI files, get their metrics, then put them into CSV file
+# How I plan to do this:
+# - Run runMetrics on the first item in midiFileNames
+#   - This will return it's metrics
+# - Create the first row of the CSV (metric measurement names, will become attribute names in Weka) of this first item
+# - Then, run a for loop for every item in midiFileNames, take it's values, and add them as a new row to the CSV
+
+
+#####
+
+# output metrics headers, by running metrics on first MIDI file
+
+# create file path to the first MIDI file (midiFileNames[0])
+midiFilePath = os.path.join(midiFolderPath, midiFileNames[0])
+
+# run runMetrics on the first item in midiFileNames
+measurements = runMetrics(midiFilePath)
+
+# open CSV file for output
+with open(midiFolderPath + "_metrics.csv", mode="w") as csvfile:
+
+   # output headers for all measurements to CSV file
+   for measurement in measurements:
+
+      keys = measurement.keysToArray()   # get attribute names for each metric
+
+      # output headers for this measurement
+      for key in keys:
+         csvfile.write(key+",")          # write them in CSV file - comma used to separate columns
+
+   # add final headers
+   csvfile.write("Index,")     # write index attribute header
+   csvfile.write("Filename")   # write filename attribute header
+
+   # run metrics for each MIDI file, and store results in CSV file
+   for midiFileName in midiFileNames:
+
+      # create path to MIDI file
+      midiFilePath = os.path.join(midiFolderPath, midiFileName)
+
+      # calculate metrics for this MIDI file
+      measurements = runMetrics(midiFilePath)
+
+      # write results to CSV file
+      writeCSVFile(measurements, midiFolderPath, midiFileName, csvfile)
+
+# now, all metrics for all MIDI files have been written to CSV file
+
+   # ***
+   # Is this needed???
+   # remember to close CSV file!!!
+   #csvfile.close()
+
+# ***
+print(midiFolderPath + "_metrics.csv written.")

creativepython-1.0.0/src/CreativePython/nevmuse/Java-Comparison-Tests/compareMetrics_Java-Vs-Python.py

@@ -0,0 +1,274 @@
+"""
+Compare two metrics CSV files cell by cell and compute statistics.
+Tracks average difference, standard deviation, and maximum difference.
+"""
+
+import csv
+import numpy as np
+from pathlib import Path
+from datetime import datetime
+import sys
+import re
+
+
+def compareMetricsCsv(file1Path, file2Path, outputFile=None):
+   """
+   Compare two CSV files cell by cell and compute statistics.
+
+   Args:
+      file1Path: Path to first CSV file (new/comparison version)
+      file2Path: Path to second CSV file (original version)
+      outputFile: Optional file object to write output to
+
+   Returns:
+      Dictionary with statistics about the differences
+   """
+
+   def printAndLog(message=""):
+      """Print to console and optionally to file"""
+      print(message)
+      if outputFile:
+         outputFile.write(message + "\n")
+
+   # read both CSV files
+   with open(file1Path, 'r', encoding='utf-8') as f1:
+      reader1 = csv.reader(f1)
+      headers1 = next(reader1)
+      rows1 = list(reader1)
+
+   with open(file2Path, 'r', encoding='utf-8') as f2:
+      reader2 = csv.reader(f2)
+      headers2 = next(reader2)
+      rows2 = list(reader2)
+
+   # verify headers match
+   if headers1 != headers2:
+      printAndLog("WARNING: Headers do not match!")
+      printAndLog(f"File 1 has {len(headers1)} columns")
+      printAndLog(f"File 2 has {len(headers2)} columns")
+      return None
+
+   printAndLog(f"Headers match: {len(headers1)} columns")
+   printAndLog(f"File 1 rows: {len(rows1)}")
+   printAndLog(f"File 2 rows: {len(rows2)}")
+
+   # verify same number of rows
+   if len(rows1) != len(rows2):
+      printAndLog("WARNING: Different number of rows!")
+      return None
+
+   # collect all numeric differences
+   allDifferences = []
+   maxDifference = 0.0
+   maxDifferenceLocation = None
+
+   # statistics by column
+   columnStats = {}
+   for colIdx, colName in enumerate(headers1):
+      columnStats[colName] = []
+
+   # statistics by metric type
+   metricTypeStats = {}
+
+   # compare each cell
+   totalCells = 0
+   numericCells = 0
+   identicalCells = 0
+
+   for rowIdx, (row1, row2) in enumerate(zip(rows1, rows2)):
+      if len(row1) != len(row2):
+         printAndLog(f"WARNING: Row {rowIdx} has different number of columns!")
+         continue
+
+      for colIdx, (val1, val2) in enumerate(zip(row1, row2)):
+         totalCells += 1
+         colName = headers1[colIdx]
+
+         # try to compare as numbers
+         try:
+            num1 = float(val1)
+            num2 = float(val2)
+            numericCells += 1
+
+            # compute absolute difference
+            diff = abs(num1 - num2)
+            allDifferences.append(diff)
+            columnStats[colName].append(diff)
+
+            # extract metric type from column name (e.g., "PitchDuration_0_Slope" -> "PitchDuration")
+            metricType = colName.split('_')[0]
+            if metricType not in metricTypeStats:
+               metricTypeStats[metricType] = []
+            metricTypeStats[metricType].append(diff)
+
+            # track maximum difference
+            if diff > maxDifference:
+               maxDifference = diff
+               maxDifferenceLocation = (rowIdx, colIdx, colName, num1, num2)
+
+            # track identical cells
+            if diff < 1e-10:   # essentially zero
+               identicalCells += 1
+
+         except ValueError:
+            # non-numeric cell (like filename), check if identical
+            if val1 == val2:
+               identicalCells += 1
+
+   # compute statistics
+   if len(allDifferences) == 0:
+      printAndLog("No numeric differences found!")
+      return None
+
+   avgDifference = np.mean(allDifferences)
+   stdDeviation = np.std(allDifferences)
+   medianDifference = np.median(allDifferences)
+
+   # print results
+   printAndLog()
+   printAndLog("=" * 80)
+   printAndLog("OVERALL STATISTICS")
+   printAndLog("=" * 80)
+   printAndLog()
+   printAndLog(f"  Total cells compared:     {totalCells:>8,}")
+   printAndLog(f"  Numeric cells:            {numericCells:>8,}")
+   printAndLog(f"  Identical cells:          {identicalCells:>8,}  ({100*identicalCells/totalCells:>5.2f}%)")
+   printAndLog(f"  Different cells:          {totalCells-identicalCells:>8,}  ({100*(totalCells-identicalCells)/totalCells:>5.2f}%)")
+   printAndLog()
+   printAndLog("  Difference Metrics:")
+   printAndLog(f"    Average difference:     {avgDifference:>12.6f}")
+   printAndLog(f"    Median difference:      {medianDifference:>12.6f}")
+   printAndLog(f"    Std deviation:          {stdDeviation:>12.6f}")
+   printAndLog(f"    Maximum difference:     {maxDifference:>12.6f}")
+
+   if maxDifferenceLocation:
+      rowIdx, colIdx, colName, val1, val2 = maxDifferenceLocation
+      printAndLog()
+      printAndLog("  Maximum Difference Details:")
+      printAndLog(f"    Row:                    {rowIdx + 2} (CSV line {rowIdx + 2})")
+      printAndLog(f"    Column:                 {colIdx}")
+      printAndLog(f"    Column name:            {colName}")
+      printAndLog(f"    Python value:           {val1}")
+      printAndLog(f"    Java value:             {val2}")
+      printAndLog(f"    Absolute difference:    {abs(val1 - val2):.10f}")
+
+   # find columns with largest average differences
+   printAndLog()
+   printAndLog("=" * 80)
+   printAndLog("TOP 10 COLUMNS WITH LARGEST AVERAGE DIFFERENCES")
+   printAndLog("=" * 80)
+   printAndLog()
+
+   columnAvgDiffs = {}
+   for colName, diffs in columnStats.items():
+      if len(diffs) > 0:
+         columnAvgDiffs[colName] = np.mean(diffs)
+
+   sortedColumns = sorted(columnAvgDiffs.items(), key=lambda x: x[1], reverse=True)
+   for rank, (colName, avgDiff) in enumerate(sortedColumns[:10], 1):
+      printAndLog(f"  {rank:2d}. {colName:55s}  {avgDiff:.8f}")
+
+   # find columns with smallest average differences (most accurate)
+   printAndLog()
+   printAndLog("=" * 80)
+   printAndLog("TOP 10 COLUMNS WITH SMALLEST AVERAGE DIFFERENCES (Most Accurate)")
+   printAndLog("=" * 80)
+   printAndLog()
+
+   for rank, (colName, avgDiff) in enumerate(reversed(sortedColumns[-10:]), 1):
+      printAndLog(f"  {rank:2d}. {colName:55s}  {avgDiff:.8f}")
+
+   # analyze by metric type
+   printAndLog()
+   printAndLog("=" * 80)
+   printAndLog("DIFFERENCES BY METRIC TYPE")
+   printAndLog("=" * 80)
+   printAndLog()
+
+   metricTypeAvgs = {}
+   for metricType, diffs in metricTypeStats.items():
+      if len(diffs) > 0:
+         metricTypeAvgs[metricType] = {
+            'avg': np.mean(diffs),
+            'max': np.max(diffs),
+            'median': np.median(diffs),
+            'std': np.std(diffs),
+            'count': len(diffs)
+         }
+
+   sortedMetricTypes = sorted(metricTypeAvgs.items(), key=lambda x: x[1]['max'], reverse=True)
+
+   printAndLog(f"{'Metric Type':<30} {'Max Diff':>12} {'Avg Diff':>12} {'Median':>12} {'Std Dev':>12} {'Count':>8}")
+   printAndLog("-" * 80)
+   for metricType, stats in sortedMetricTypes:
+      printAndLog(f"{metricType:<30} {stats['max']:>12.6f} {stats['avg']:>12.6f} {stats['median']:>12.6f} {stats['std']:>12.6f} {stats['count']:>8,}")
+
+   return {
+      'avgDifference': avgDifference,
+      'stdDeviation': stdDeviation,
+      'maxDifference': maxDifference,
+      'medianDifference': medianDifference,
+      'totalCells': totalCells,
+      'numericCells': numericCells,
+      'identicalCells': identicalCells,
+      'columnStats': columnStats,
+      'metricTypeStats': metricTypeStats
+   }
+
+
+if __name__ == "__main__":
+   # get script directory to make paths relative to script location
+   scriptDir = Path(__file__).parent
+
+   # define file paths relative to script location
+   newFile = scriptDir / "Bach AoF Fugues_metrics.csv"
+   originalFile = scriptDir / "ORIGINAL-JAVA_Bach AoF Fugues_metrics.csv"
+
+   # create results directory if it doesn't exist
+   resultsDir = scriptDir / "results"
+   resultsDir.mkdir(exist_ok=True)
+
+   # create timestamped output filename
+   timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+   outputFilename = resultsDir / f"comparison_{timestamp}.txt"
+
+   print("=" * 80)
+   print("METRICS COMPARISON: Python Implementation vs Java Implementation")
+   print("=" * 80)
+   print()
+   print(f"Python results file:  {newFile.name}")
+   print(f"Java results file:    {originalFile.name}")
+   print(f"Output file:          {outputFilename.relative_to(scriptDir)}")
+   print()
+
+   # verify files exist
+   if not newFile.exists():
+      print(f"ERROR: File not found: {newFile}")
+      sys.exit(1)
+   if not originalFile.exists():
+      print(f"ERROR: File not found: {originalFile}")
+      sys.exit(1)
+
+   # run comparison and save to file
+   with open(outputFilename, 'w', encoding='utf-8') as outFile:
+      # write header to file
+      outFile.write("=" * 80 + "\n")
+      outFile.write("METRICS COMPARISON: Python Implementation vs Java Implementation\n")
+      outFile.write("=" * 80 + "\n")
+      outFile.write(f"\nGenerated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+      outFile.write(f"Python results file:  {newFile.name}\n")
+      outFile.write(f"Java results file:    {originalFile.name}\n")
+      outFile.write("\n")
+
+      # run comparison
+      results = compareMetricsCsv(newFile, originalFile, outFile)
+
+   if results:
+      print()
+      print("=" * 80)
+      print("COMPARISON COMPLETE!")
+      print("=" * 80)
+      print(f"\nResults saved to: {outputFilename}")
+   else:
+      print("\nComparison failed!")
+      sys.exit(1)