CreativePython 0.3.6__tar.gz → 1.0.0__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "CreativePython"
-version = "0.3.6"
+version = "1.0.0"
 description = "A Python-based software environment for developing algorithmic art projects."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -33,7 +33,8 @@ 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]
@@ -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.6 → creativepython-1.0.0}/src/CreativePython/notationRenderer.py

@@ -19,7 +19,6 @@
 import xml.etree.ElementTree as ET
 from xml.dom import minidom
 import os
-import subprocess
 import sys
 
 # NOTE: Local, function-level imports are used in this module. This is a
@@ -73,7 +72,7 @@ _DRUM_MAP = {
 
 ### API (called from music.py) ###############################################
 
-def _showNotation(score, title="Sheet Music"):
+def _showNotation(score, title="Sheet Music", writeToFile=False):
    """
    Renders a Score object into visual sheet music and displays it.
 
@@ -103,10 +102,10 @@ def _showNotation(score, title="Sheet Music"):
       # fallback for interactive sessions
       script_dir = os.getcwd()
 
-   output_dir = os.path.join(script_dir, "notation")
+   # output_dir = os.path.join(script_dir, "notation")
 
-   # create the notation directory if it doesn't exist
-   os.makedirs(output_dir, exist_ok=True)
+   # # create the notation directory if it doesn't exist
+   # os.makedirs(output_dir, exist_ok=True)
 
    # Generate filename from title
    if title and title.strip() and title.strip() != "Untitled Score":
@@ -115,7 +114,7 @@ def _showNotation(score, title="Sheet Music"):
    else:
       svg_filename = "sheet_music.svg"
 
-   output_path = os.path.join(output_dir, svg_filename)
+   output_path = os.path.join(script_dir, svg_filename)
 
    # generate MusicXML
    musicxml = _scoreToMusicXML(score)
@@ -125,7 +124,7 @@ def _showNotation(score, title="Sheet Music"):
 
    if svg is not None:
       # success - save file and open in viewer
-      _openInViewer(svg, output_path)
+      _openInViewer(svg, output_path, writeToFile)
       print(f"Sheet music saved to: {output_path}")
       return True
    else:
@@ -768,7 +767,10 @@ def _renderToSVG(musicxml):
       return None   # verovio not available
 
    # create toolkit
-   tk = verovio.toolkit()
+   tk = verovio.toolkit(False)
+
+   # ensure verovio fonts are available
+   tk.setResourcePath(os.path.join(os.path.dirname(verovio.__file__), "data"))
 
    # configure options for the svg output, controlling layout and appearance
    tk.setOptions({
@@ -787,7 +789,7 @@ def _renderToSVG(musicxml):
    return svg
 
 
-def _openInViewer(svg, path):
+def _openInViewer(svg, path, writeToFile):
    """
    Saves an SVG string to a file and opens it with the default system viewer.
 
@@ -799,17 +801,65 @@ def _openInViewer(svg, path):
       svg (str): The SVG data to save and display.
       path (str): The absolute file path to save the SVG to.
    """
-   # save to specified path
-   with open(path, 'w', encoding='utf-8') as f:
-      f.write(svg)
-
-   # use the appropriate system command to open the file in the default viewer
-   if sys.platform == 'win32':
-      os.startfile(path)
-   elif sys.platform == 'darwin':   # macOS
-      subprocess.run(['open', path])
-   else:   # linux
-      subprocess.run(['xdg-open', path])
+   import pathlib, webbrowser, tempfile, urllib.parse
+
+   if writeToFile:
+      # save to specified path
+      with open(path, 'w', encoding='utf-8') as f:
+         f.write(svg)
+         svgPath = pathlib.Path(path).expanduser().resolve()  # absolute path to written SVG
+
+   else:
+      # save to temporary location
+      with tempfile.NamedTemporaryFile("w", suffix=".svg", delete=False) as f:
+         f.write(svg)
+         svgPath = pathlib.Path(f.name).resolve()  # absolute path to temporary SVG
+
+   if svgPath.is_file():
+      svgURL = svgPath.as_uri()  # convert filepath to URL (with correct space handling)
+
+      # generate minimal HTML wrapper
+      # SVG is a generic document type, so often get opened in text editors
+      # (TextMate, VSCode, etc.).  We want to open the SVG in the user's
+      # default web browser, so we wrap it in HTML before opening.
+      html = f"""<!doctype html>
+      <html>
+      <head>
+         <meta charset="utf-8">
+         <meta name="viewport" content="width=device-width, initial-scale=1">
+         <title>{svgPath.name}</title>
+         <style>
+            html, body {{ height: 100%; margin: 0; }}
+            body {{ display: grid; place-items: center; background: #fff; }}
+            img {{ max-width: 100vw; max-height: 100vh; }}
+         </style>
+      </head>
+      <body>
+         <img src="{svgURL}" alt="{svgPath.name}">
+      </body>
+      </html>
+      """
+
+      # write wrapper to a temporary file
+      with tempfile.NamedTemporaryFile("w", suffix=".html", delete=False, encoding="utf-8") as f:
+         f.write(html)
+         htmlPath = pathlib.Path(f.name).resolve()  # absolute path to HTML
+         htmlURL = htmlPath.as_uri()  # convert to URL
+
+      ok = webbrowser.open(htmlURL, new=2)  # open in new tab, if possible
+      if not ok:
+         webbrowser.open(htmlURL)  # fallback to new browser window
+
+   else:
+      print(f"View.notate(): Couldn't open generated SVG '{path}' (You can open this notation in most web browsers).")
+
+   # # use the appropriate system command to open the file in the default viewer
+   # if sys.platform == 'win32':
+   #    os.startfile(path)
+   # elif sys.platform == 'darwin':   # macOS
+   #    subprocess.run(['open', path])
+   # else:   # linux
+   #    subprocess.run(['xdg-open', path])
 
 
 def _saveMusicXML(musicxml, filename):

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

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

@@ -11,7 +11,4 @@ pooch>=1.8
 pypianoroll>=1.0
 verovio>=5.6.0
 pymusicxml>=0.5.6
-
-[dev]
-build
-twine
+pyinstaller>=6.16.0

{creativepython-0.3.6 → creativepython-1.0.0}/src/gui.py

@@ -5,11 +5,7 @@
 import PySide6.QtWidgets as _QtWidgets
 import PySide6.QtGui as _QtGui
 import PySide6.QtCore as _QtCore
-import PySide6.QtSvg as _QtSvg
 import PySide6.QtOpenGLWidgets as _QtOpenGL
-import PySide6.QtWebEngineCore as _QtWeb
-import PySide6.QtWebEngineWidgets as _QtWebW
-import PySide6.QtSvg as _QtSvg
 import numpy as np
 #######################################################################################
 
@@ -1468,6 +1464,8 @@ class Drawable:
       self._originalWidth  = 0     # initial dimensions, used for rebuilding shapes
       self._originalHeight = 0     # ...
       self._rotation       = 0     # ...
+      self._anchorX        = None  # ... rotation origin, defaults to center if not set
+      self._anchorY        = None  # ...
       self._toolTipText    = None  # text to Display on mouse over (None == disabled)
 
    def __str__(self):
@@ -1598,19 +1596,68 @@ class Drawable:
       """
       return int(self._rotation)
 
-   def setRotation(self, rotation):
+   def setRotation(self, rotation, anchorX=None, anchorY=None):
       """
       Sets the item's rotation (in degrees).
       Rotation starts at 3 o'clock, increasing counter-clockwise.
-      Items rotate around their x, y position.
+      Items rotate around their center by default,
+      or around the origin, if specified.
       """
-      oldRotation = self.getRotation()
-      rotationDelta = rotation - oldRotation
-      if (int(rotationDelta) != 0):  # skip if no change
-         self._rotation = rotation
-         qtRotation = -rotation % 360  # reverse increasing direction (CCW -> clockwise)
-         self._qObject.prepareGeometryChange()  # invalidate Qt hitbox
-         self._qObject.setRotation(qtRotation)  # update rotation
+      if anchorX is not None:
+         # anchorX is specified, so remember it for later
+         self._anchorX = anchorX
+      else:
+         # anchorX isn't specified, so use existing anchor
+         if self._anchorX is not None:
+            # anchorX has been set before, so use it
+            anchorX = self._anchorX
+         else:
+            # anchorX hasn't been set yet, so default to centerX
+            anchorX = self.getWidth() / 2
+
+      if anchorY is not None:
+         # anchorY is specified, so remember it for later
+         self._anchorY = anchorY
+      else:
+         # anchorY isn't specified, so use existing anchor
+         if self._anchorY is not None:
+            # anchorY has been set before, so use it
+            anchorY = self._anchorY
+         else:
+            # anchorY hasn't been set yet, so default to centerY
+            anchorY = self.getHeight() / 2
+
+      self._rotation = rotation     # remember rotation
+      qtRotation = -rotation % 360  # reverse increasing direction (CCW -> clockwise)
+      self._qObject.setTransformOriginPoint(anchorX, anchorY)
+      self._qObject.prepareGeometryChange()  # invalidate Qt hitbox
+      self._qObject.setRotation(qtRotation)  # update rotation
+
+   def getAnchor(self):
+      """
+      Returns the item's (x, y) anchor position (in pixels).
+      Rotations are centered around the anchor, relative to the item's position.
+      """
+      anchorX = self._anchorX
+      anchorY = self._anchorY
+
+      # default to center coordinates
+      if anchorX is None:
+         anchorX = self.getWidth() / 2
+      if anchorY is None:
+         anchorY = self.getHeight() / 2
+
+      return (int(anchorX), int(anchorY))
+
+   def setAnchor(self, anchorX, anchorY):
+      """
+      Sets the item's (x, y) anchor position (in pixels).
+      Rotations are centered around the anchor, relative to the item's position.
+      Setting either anchor to None defaults to the center.
+      """
+      self._anchorX  = anchorX
+      self._anchorY  = anchorY
+      # we don't need to alter the Qt object until the rotation changes
 
    ##### CONVENIENCE METHODS
    # These methods are aliases for the methods above,
@@ -1674,11 +1721,11 @@ class Drawable:
       x, y = self.getPosition()
       self.setPosition(x + dx, y + dy)
 
-   def rotate(self, angle):
+   def rotate(self, angle, anchorX=None, anchorY=None):
       """
       Rotates the item by the given angle (in degrees).
       """
-      self.setRotation(self.getRotation() + angle)
+      self.setRotation(self.getRotation() + angle, anchorX, anchorY)
 
    ##### LOCATION TESTS
    # These methods help with hit testing and location detection.
@@ -2209,12 +2256,18 @@ class Control(Drawable, Interactable):
       self._width  = width
       self._height = height
 
-   def setRotation(self, rotation):
+   def setRotation(self, rotation, anchorX=None, anchorY=None):
       """
       Controls cannot be rotated.
       """
       print(f"{type(self).__name__}.setRotation(): Controls cannot be rotated.")
 
+   def setAnchor(self, anchorX, anchorY):
+      """
+      Controls cannot be rotated, so anchors cannot be set.
+      """
+      print(f"{type(self).__name__}.setAnchor(): Controls cannot be rotated, so anchors cannot be set.")
+
 
 #######################################################################################
 # Graphics Objects (Geometric shapes, text, and images)
@@ -2893,41 +2946,11 @@ class Icon(Graphics):
       Read more: https://doc.qt.io/qt-6/qpixmap.html#reading-and-writing-image-files
       """
       Graphics.__init__(self)
+      from pathlib import Path
+      path = Path(filename)
 
       # initialize internal shape
       try:
-#          if filename.lower().endswith(".svg"):  # rasterize SVG file
-#             # render with QWebEngine... (fails to launch web event loop)
-#             view = _QtWebW.QWebEngineView()
-#             with open(filename, "r", encoding="utf-8") as f:
-#                svg = f.read()
-
-#             html = f"""
-# <!DOCTYPE html>
-# <html>
-#    <body style="margin:0; padding:0; overflow:hidden;">
-#       {svg}
-#    </body>
-# </html>
-# """
-#             view.setHtml(html, _QtCore.QUrl.fromLocalFile(filename))
-#             view.show()
-#             size = _QtCore.QSize(600, 400)
-#             pixmap = _QtGui.QPixmap(size)
-#             pixmap.fill(_QtGui.QColorConstants.Transparent)
-
-         #    # render with SVG Renderer... (only supports Tiny 1.2)
-         #    renderer = _QtSvg.QSvgRenderer(filename)
-         #    size = renderer.defaultSize()
-         #    pixmap = _QtGui.QPixmap(size)
-         #    pixmap.fill(_QtGui.QColorConstants.Transparent)
-         #    painter = _QtGui.QPainter(pixmap)
-         #    renderer.render(painter)
-         #    painter.end()
-
-         # else:
-         #    pixmap = _QtGui.QPixmap(filename)  # create pixmap from file
-
          pixmap = _QtGui.QPixmap(filename)  # create pixmap from file
 
          if width is None and height is None:  # no scaling needed
@@ -2940,7 +2963,7 @@ class Icon(Graphics):
 
          scaledPixmap = pixmap.scaled(width, height)  # scale new pixmap
 
-      except:  # ... create blank pixmap if import fails (used intentionally in Image)
+      except:   # ... create blank pixmap if file fails to load
          if width is None:
             width = 600
          if height is None:
@@ -3184,7 +3207,7 @@ class Label(Graphics):
       """
       return self.getColor()
 
-   def setForegroundColor(self, color):
+   def setForegroundColor(self, color=None):
       """
       Sets the label's font color.
       If no color is provided, a color selection box will appear.
@@ -3198,13 +3221,19 @@ class Label(Graphics):
       r, g, b, a = self._backgroundColor
       return Color(r, g, b, a)
 
-   def setBackgroundColor(self, color):
+   def setBackgroundColor(self, color=None):
       """
       Sets the label's background color.
       If no color is provided, a color selection box will appear.
       """
-      if color is None:  # choose a color
-         pass  # TODO: add color selection box
+      if color is None:
+         # open color selector if no value provided
+         r, g, b = _selectColor()
+         color = Color(r, g, b)
+
+      elif not isinstance(color, Color):
+         # throw error if wrong data type entered
+         raise TypeError(f'{type(self).__name__}.setBackgroundColor(): color should be a Color object (it was {type(color).__name__})')
 
       r, g, b, a = color.getRGBA()
       self._backgroundColor = [r, g, b, a]

{creativepython-0.3.6 → creativepython-1.0.0}/src/image.py

@@ -56,7 +56,6 @@ class Image():
    def _fromPNGBytes(data):
       """
       Returns a new Image object built from raw PNG data.
-      Used by music.View to render images from Verovio.
       """
       icon = Icon._fromPNGBytes(data)  # generate icon from data
       width, height = icon.getSize()   # get icon dimensions

{creativepython-0.3.6 → creativepython-1.0.0}/src/midi.py

@@ -21,7 +21,8 @@
 
 import mido                                    # provides MIDI input/output and message handling
 from timer import Timer2                       # for scheduling MIDI events
-from gui import Display, DropDownList, Color   # gui elements for MIDI device selection and display
+# from gui import Display, DropDownList, Color   # gui elements for MIDI device selection and display
+# gui elements are lazy-loaded only when device selection GUI is needed
 import PySide6.QtCore as _QtCore               # Qt core utilities for event handling and integration
 from music import freqToNote                   # converts frequency values to MIDI note numbers
 import atexit                                  # ensures cleanup of MIDI resources on program exit
@@ -167,6 +168,8 @@ class MidiIn(_QtCore.QObject):
          items.sort()
 
          if len(items) > 0:   # if availabale inputs exist
+            from gui import Display, DropDownList, Color
+
             # create selection display
             self.display = Display("Select MIDI Input", 400, 125) # display info to user
             self.display.drawLabel('Select a MIDI input device from the list', 45, 30)
@@ -916,6 +919,8 @@ class MidiOut:
          items.sort()
 
          if len(items) > 0:   # if available outputs exist
+            from gui import Display, DropDownList, Color
+
             # create selection display
             self.display = Display("Select MIDI Output", 400, 125) # display info to user
             self.display.drawLabel('Select a MIDI output device from the list', 45, 30)

{creativepython-0.3.6 → creativepython-1.0.0}/src/music.py

@@ -3318,25 +3318,34 @@ class Mod():
          raise TypeError(f"Unrecognized material type {type(material)} - expected Phrase, Part, or Score.")
 
    @staticmethod
-   def invert(phrase, pitchAxis):
+   def invert(phrase, pitchAxis, scale=CHROMATIC_SCALE, key=0):
       """
       Invert phrase using pitch as the mirror (pivot) axis.
       phrase:    Phrase to invert
       pitchAxis: Pitch axis to pivot around (0-127)
+      scale:     
       """
       # do some basic error checking
       if type(pitchAxis) is not int:
          raise TypeError(f"Unrecognized pitchAxis type {type(pitchAxis)} - expected int.")
       if type(phrase) is not Phrase:
          raise TypeError(f"Unrecognized material type {type(phrase)} - expected Phrase.")
+
       # traverse list of notes, and adjust pitches accordingly
+      smallestDuration = None
+
       for note in phrase.getNoteList():
 
          if not note.isRest():  # modify regular notes only (i.e., do not modify rests)
             invertedPitch = pitchAxis + (pitchAxis - note.getPitch())   # find mirror pitch around axis (by adding difference)
             note.setPitch(invertedPitch)                                # and update it
 
-      # now, all notes have been updated
+            if (smallestDuration is None) or (note.getDuration() < smallestDuration):
+               # track the smallest non-REST duration in the phrase
+               smallestDuration = note.getDuration()
+
+      # now, all notes have been updated.  Next, quantize to filter into the given scale
+      Mod.quantize(phrase, smallestDuration, scale, key)
 
    @staticmethod
    def merge(material1, material2):
@@ -3475,19 +3484,32 @@ class Mod():
       to fit multiples of quantum (e.g., 1.0), using the specified scale (e.g., MAJOR_SCALE),
       and the specified tonic (0 means C, 1 means C sharp, 2 means D, and so on).
       """
-
       # define helper functions
       def quantizeNote(note):
          """Helper function to quantize a note."""
-         if note.getPitch() != REST:             # ignore rests
-            interval = note.getPitch() % 12
-            while interval not in scale:        # if pitch is not in the scale...
-               interval -= 1                       # lower pitch by one semitone
-
+         if note.getPitch() != REST:  # ignore rests
             # calculate new duration as a multiple of quantum
             newDuration = round(note.getDuration() / quantum) * quantum
             note.setDuration(newDuration)
 
+            # coerce new pitch to given scale
+            noteInterval = note.getPitch() % 12  # interval from base key
+            noteKey = note.getPitch() - noteInterval  # base key
+            i = len(scale) - 1
+
+            while i >= 0:  # check each interval in scale, back to front
+               scaleInterval = scale[i]
+               if noteInterval >= scaleInterval:
+                  # set noteInterval to first scaleInterval it exceeds
+                  noteInterval = scaleInterval
+                  i = -1  # break
+               else:
+                  i = i - 1
+
+            # adjust pitch accordingly
+            newPitch = noteKey + noteInterval
+            note.setPitch(newPitch)
+
       def quantizePhrase(phrase):
          """Helper function to quantize a phrase."""
          for note in phrase.getNoteList():
@@ -3503,25 +3525,25 @@ class Mod():
          for part in score.getPartList():
             quantizePart(part)
 
-         # check type of steps
-         if type(quantum) is not int:
-            raise TypeError( "Unrecognized quantum type " + str(type(quantum)) + " - expected int." )
+      # check type of steps
+      if type(quantum) not in (int, float):
+         raise TypeError( "Unrecognized quantum type " + str(type(quantum)) + " - expected a number." )
 
-         # check type of material and execute the appropriate code
-         if isinstance(material, Score):
-            quantizeScore(material)
+      # check type of material and execute the appropriate code
+      if isinstance(material, Score):
+         quantizeScore(material)
 
-         elif isinstance(material, Part):
-            quantizePart(material)
+      elif isinstance(material, Part):
+         quantizePart(material)
 
-         elif isinstance(material, Phrase):
-            quantizePhrase(material)
+      elif isinstance(material, Phrase):
+         quantizePhrase(material)
 
-         elif isinstance(material, Note):
-            quantizeNote(material)
+      elif isinstance(material, Note):
+         quantizeNote(material)
 
-         else:   # error check
-            raise TypeError( "Unrecognized material type " + str(type(material)) + " - expected Note, Phrase, Part, or Score." )
+      else:   # error check
+         raise TypeError( "Unrecognized material type " + str(type(material)) + " - expected Note, Phrase, Part, or Score." )
 
    @staticmethod
    def randomize(material, pitchAmount, durationAmount=0, volumeAmount=0):
@@ -6404,9 +6426,10 @@ class View:
          print(f'View.sketch(): Unrecognized type {type(material)}, expected Score, Part, or Phrase.')
 
    @staticmethod
-   def notate(material):
+   def notate(material, writeToFile=False):
       """
       Visualize music as staff notation, where material may be a Score, Part, or Phrase.
+      Setting writeToFile to True saves the visualization as an SVG file.
       """
       # import internal notation renderer
       from CreativePython.notationRenderer import _showNotation
@@ -6424,7 +6447,7 @@ class View:
          title = material.getTitle() if material.getTitle() else "Sheet Music"
 
          # delegate to internal renderer
-         _showNotation(material, title)
+         _showNotation(material, title, writeToFile)
 
       else:
          print("View.notate: material must be a Score, Part, Phrase, or Note.")

{creativepython-0.3.6 → creativepython-1.0.0}/src/timer.py

@@ -18,15 +18,7 @@
 #
 ###############################################################################
 
-# Timer (uses Qt's timer, intended for endusers to avoid gui conflicts)
-from PySide6.QtWidgets import QApplication
-from PySide6.QtCore    import QTimer
-from PySide6 import QtCore as _QtCore
-
-# Timer2 (a custom implementation, used internally)
-import threading
-import time
-import atexit
+import threading, time, atexit
 
 ##############################################################################
 # ensure a QApplication exists (needed for QTimer in Timer class)
@@ -38,6 +30,8 @@ def _ensureApp():
    # this function is called whenever we create a new display,
    # or queue a function that modifies the display (or the display's items)
    global _QTAPP_
+   from PySide6.QtWidgets import QApplication
+
    if _QTAPP_ is None:
       # try to find an existing QApplication instance
       _QTAPP_ = QApplication.instance()
@@ -52,9 +46,6 @@ def _ensureApp():
             }
             """)
 
-_ensureApp()
-
-
 ###############################################################################
 # Timer
 #
@@ -90,6 +81,13 @@ class Timer():
    def __init__ (self, timeInterval, function, parameters=[], repeat=True):
       """Specify time interval (in milliseconds), which function to call when the time interval has passed
          and the parameters to pass this function, and whether to repeat (True) or do it only once."""
+      # lazy import Qt modules only when Timer is instantiated
+      from PySide6.QtCore import QTimer
+      from PySide6 import QtCore as _QtCore
+      
+      # ensure QApplication exists before creating QTimer
+      _ensureApp()
+
       # create an internal QTimer
       self._timer = QTimer()                                        # default QTimer() is a CoarseTimer
       self._timer.setTimerType(_QtCore.Qt.TimerType.PreciseTimer)   # use PreciseTimer for smoother animations

{creativepython-0.3.6 → creativepython-1.0.0}/src/zipf.py

@@ -58,8 +58,8 @@
 # version 1.0 (May 10, 2003)
 #
 
-from CreativePython.nevmuse import *
-from math import log, sqrt   # for logarithmic calculations
+from CreativePython.nevmuse import *   # Zipf Metrics
+from math import log, sqrt             # logarithmic calculations
 
 
 def byRank(counts):
@@ -251,16 +251,93 @@ def measureMidi(files, metrics, quantum=0.25):
    return measureScore(scores, metrics, quantum)
 
 
+def measureDataByRank(datasets, metricName="ByRank"):
+   """
+   Calculates Zipf rank-frequency metrics for raw data.
+
+   datasets: list of lists - each inner list is a list of numeric frequency values
+             Example: [[10, 5, 3], [20, 15, 10], ...]
+   metricName: string - name for the metric in CSV headers (default: "ByRank")
+
+   Returns a list of lists - each inner list contains [SimpleMeasurement]
+            compatible with writeCSV()
+   """
+   # validate datasets is a list
+   if not isinstance(datasets, list):
+      raise TypeError("datasets must be a list")
+
+   if len(datasets) == 0:
+      raise TypeError("datasets must be a non-empty list")
+
+   allMeasurements = []
+
+   for counts in datasets:
+      # call byRank to get slope, r2, yint
+      slope, r2, yint = byRank(counts)
+
+      # create SimpleMeasurement object
+      measurement = _SimpleMeasurement(metricName, slope, r2, yint)
+
+      # append [measurement] to results
+      allMeasurements.append([measurement])
+
+   return allMeasurements
+
+
+def measureDataBySize(datasets, metricName="BySize"):
+   """
+   Calculates Zipf size-frequency metrics for raw data.
+
+   datasets: list of [sizes, counts] pairs
+             Each element is [sizes, counts] where:
+               sizes: list of numeric values (x-axis)
+               counts: list of numeric values (y-axis)
+             Example: [[[1, 2, 3], [10, 8, 5]], [[5, 10, 15], [20, 15, 10]], ...]
+   metricName: string - name for the metric in CSV headers (default: "BySize")
+
+   Returns a list of lists - each inner list contains [SimpleMeasurement]
+            compatible with writeCSV()
+   """
+   # validate datasets is a list
+   if not isinstance(datasets, list):
+      raise TypeError("datasets must be a list")
+
+   if len(datasets) == 0:
+      raise TypeError("datasets must be a non-empty list")
+
+   allMeasurements = []
+
+   for dataset in datasets:
+      # unpack each dataset
+      try:
+         sizes, counts = dataset
+      except (ValueError, TypeError):
+         raise TypeError("each dataset must be a list [sizes, counts]")
+
+      # call bySize to get slope, r2, yint
+      slope, r2, yint = bySize(sizes, counts)
+
+      # create SimpleMeasurement object
+      measurement = _SimpleMeasurement(metricName, slope, r2, yint)
+
+      # append [measurement] to results
+      allMeasurements.append([measurement])
+
+   return allMeasurements
+
+
 def writeCSV(measurements, filename):
    """
    Writes Zipf metric results to a CSV file.
-   Measurements should come from measureScore or measureMidi.
+   Measurements should come from measureScore, measureMidi, measureDataByRank, or measureDataBySize.
 
-   measurements: list of lists - results from measureMidi/measureScore
-                 each inner list contains [Measurement1, Measurement2, ..., filename]
+   measurements: list of lists - results from measure functions
+                 Format 1 (with labels): [Measurement1, Measurement2, ..., label]
+                 Format 2 (no labels): [Measurement1, Measurement2, ...]
    filename: string - output CSV file path
 
-   Creates a CSV with columns: metric values..., Index, Filename
+   Creates a CSV with columns: metric values..., Index
+   Or with labels: metric values..., SourceName, Index
    """
    import os
    import unicodedata
@@ -273,13 +350,23 @@ def writeCSV(measurements, filename):
    if not isinstance(measurements[0], (list, tuple)):
       raise TypeError("measurements must be a list of lists (from measureMidi/measureScore)")
 
-   # extract filenames from last element of each inner list
+   # check if the last element is a label (string) or a Measurement object
+   # to determine if we have source names
+   lastElement = measurements[0][-1]
+   hasSourceNames = isinstance(lastElement, str)
+
+   # extract measurements and optional names
    measurementsList = []
    names = []
-   for measurementRow in measurements:
-      # last element is the filename, everything else is Measurement objects
-      measurementsList.append(measurementRow[:-1])
-      names.append(measurementRow[-1])
+   if hasSourceNames:
+      for measurementRow in measurements:
+         # last element is the name/label, everything else is Measurement objects
+         measurementsList.append(measurementRow[:-1])
+         names.append(measurementRow[-1])
+   else:
+      # all elements are Measurement objects
+      for measurementRow in measurements:
+         measurementsList.append(measurementRow)
 
    # helper function to convert to ASCII (from advMetricRunner.jythonSurvey.py)
    def convertToASCII(string):
@@ -306,9 +393,10 @@ def writeCSV(measurements, filename):
          for key in keys:
             csvfile.write(key + ",")
 
-      # add final headers (Index and Filename columns)
-      csvfile.write("Index,")
-      csvfile.write("Filename")   # no trailing comma, no newline yet
+      # add final headers (SourceName and/or Index columns)
+      if hasSourceNames:
+         csvfile.write("SourceName,")
+      csvfile.write("Index")   # no trailing comma, no newline yet
 
       # write data rows
       for i, measurements in enumerate(measurementsList):
@@ -320,16 +408,43 @@ def writeCSV(measurements, filename):
             for value in values:
                csvfile.write(convertToASCII(value) + ",")
 
-         # write index (1-based, like advMetricRunner)
+         # write source name if present
+         if hasSourceNames:
+            sourceName = names[i]
+            if os.path.sep in sourceName:
+               sourceName = os.path.basename(sourceName)
+            sourceName = convertToASCII(sourceName)
+            csvfile.write(sourceName + ",")
+
+         # write index (1-based, last column, no trailing comma or newline)
          index = i + 1
-         csvfile.write(convertToASCII(index) + ",")
+         csvfile.write(convertToASCII(index))
+
 
-         # write filename (last column, no trailing comma or newline)
-         sourceName = names[i]
-         if os.path.sep in sourceName:
-            sourceName = os.path.basename(sourceName)
-         sourceName = convertToASCII(sourceName)
-         csvfile.write(sourceName)
+class _SimpleMeasurement:
+   """
+   Simple measurement object for raw Zipf analysis.
+   Compatible with writeCSV() but produces cleaner output than standard Measurement class.
+   Only includes Slope, R2, and Y-Intercept columns (no LocalVariability fields).
+   """
+
+   def __init__(self, metricName, slope, r2, yint):
+      self.metricName = metricName
+      self.slope = slope
+      self.r2 = r2
+      self.yint = yint
+
+   def keysToArray(self):
+      """Returns column headers for CSV output"""
+      return [
+         f"{self.metricName}_Slope",
+         f"{self.metricName}_R2",
+         f"{self.metricName}_YInt"
+      ]
+
+   def valuesToArray(self):
+      """Returns values for CSV output"""
+      return [self.slope, self.r2, self.yint]
 
 
 if __name__ == '__main__':
@@ -364,3 +479,42 @@ if __name__ == '__main__':
    sizes = histogram.keys()
    slope, r2, yint = bySize(sizes, counts)
    print(f"The bySize slope is {slope} and the R^2 is {r2}")
+
+   # Test measureDataByRank
+   print("\n=== Testing measureDataByRank ===")
+   rankDatasets = [
+      [10, 5, 5, 3, 3, 3],
+      [20, 15, 10, 5],
+      [100, 50, 33, 25, 20]
+   ]
+   rankResults = measureDataByRank(rankDatasets)
+   print(f"Results: {len(rankResults)} datasets analyzed")
+   for i, row in enumerate(rankResults, 1):
+      measurement = row[0]
+      print(f"  Dataset {i}: slope={measurement.slope:.3f}, r2={measurement.r2:.3f}, yint={measurement.yint:.3f}")
+
+   # Test measureDataBySize
+   print("\n=== Testing measureDataBySize ===")
+   sizeDatasets = [
+      [[1, 2, 3, 4], [10, 8, 5, 2]],
+      [[5, 10, 15], [20, 15, 10]]
+   ]
+   sizeResults = measureDataBySize(sizeDatasets)
+   print(f"Results: {len(sizeResults)} datasets analyzed")
+   for i, row in enumerate(sizeResults, 1):
+      measurement = row[0]
+      print(f"  Dataset {i}: slope={measurement.slope:.3f}, r2={measurement.r2:.3f}, yint={measurement.yint:.3f}")
+
+   # Test CSV compatibility - separate files for different metric types
+   print("\n=== Testing CSV output ===")
+   writeCSV(rankResults, "test_zipf_rank.csv")
+   print("Rank CSV file created successfully")
+
+   writeCSV(sizeResults, "test_zipf_size.csv")
+   print("Size CSV file created successfully")
+
+   # Test custom metric names
+   print("\n=== Testing custom metric names ===")
+   customResults = measureDataByRank(rankDatasets, metricName="CustomFreq")
+   writeCSV(customResults, "test_zipf_custom.csv")
+   print("Custom metric CSV file created successfully")