style cleanup

Author: Cornerback24

MidiData.py

@@ -3,70 +3,92 @@
 from TrackData import TempoChanges
 from MidiEvents import *
 
-#contains the finalized data after anylisis
+
+# contains the finalized data after analysis
 class MidiData:
     def __init__(self, midiFilename):
         self.eventDecoder = MidiEventDecoder(midiFilename)
         headerData = self.eventDecoder.headerData()
-        #variables
+        # variables
         self.format = headerData.formatType
         self.numTracks = headerData.numTracks
         self.isTicksPerBeat = False
-        if headerData.ticksPerBeat == None:
+        if headerData.ticksPerBeat is None:
             self.isTicksPerBeat = False
             self.ticksPerSecond = (headerData.framesPerSecond *
                                    headerData.ticksPerFrame)
         else:
             self.isTicksPerBeat = True
             self.ticksPerBeat = headerData.ticksPerBeat
 
-        #maps running total of delta times to microsecondsPerQuarter
+        if headerData.formatType != 1:
+            raise NotSupportedException("Midi files of format " + str(headerData.formatType)
+                                        + " are not supported")
+
+        # maps running total of delta times to microsecondsPerQuarter
         tempoChanges = TempoChanges()
         self.tracks = []
 
-        deltaTimeTotal = 0
-        self.msPerBeat = 500 #default 120 bpm
+        self.msPerBeat = 500  # default 120 bpm
 
-        #read in each track
-        tracknum = 0 #used to create temporary track names
+        # read in each track
+        tracknum = 0  # used to create temporary track names
         while self.eventDecoder.hasMoreEvents():
             trackName = "Track" + str(tracknum)
-            tracknum = tracknum + 1
-            #should be a track header
+            tracknum += 1
             trackData = TrackData(trackName)
+            # should be a track header
             event = self.eventDecoder.nextEvent()
-            #set up tempoChanges
+            if not(isinstance(event, TrackHeader)):
+                raise UnexpectedEventException(event, TrackHeader())
+            # set up tempoChanges
             tempoChanges.reset()
-            self.msPerBeat = 500 #default 120 bpm
+            self.msPerBeat = 500  # default 120 bpm
             deltaTimeTotal = 0
-            nextTotal = 0
-            msTotal = 0 #current time in ms
-            #add events
+            msTotal = 0  # current time in ms
+            # add events
             while not(isinstance(event, EndOfTrackEvent)):
                 event = self.eventDecoder.nextEvent()
-                if (isinstance(event, SetTempoEvent)):
+                if isinstance(event, SetTempoEvent):
                     tempoChanges.addTempoChange(deltaTimeTotal, event.tempo)
                 nextTotal = deltaTimeTotal + event.deltaTime
-                #calcaute absolute start time for event in ms
+                # calculate absolute start time for event in ms
                 if self.isTicksPerBeat:
                     while (tempoChanges.hasMore() and
                            nextTotal >= tempoChanges.deltaTimeTotal()):
-                        msTotal = msTotal + ((tempoChanges.deltaTimeTotal() -
-                                     deltaTimeTotal)*self.msPerBeat/self.ticksPerBeat)
+                        msTotal += ((tempoChanges.deltaTimeTotal() - deltaTimeTotal)*self.msPerBeat/self.ticksPerBeat)
                         deltaTimeTotal = tempoChanges.deltaTimeTotal()
                         self.msPerBeat = tempoChanges.usPerQuarter()*.001
                         tempoChanges.findNext()
-                    msTotal = (msTotal +
-                           ((nextTotal-deltaTimeTotal)*self.msPerBeat/self.ticksPerBeat))
+                    msTotal += ((nextTotal-deltaTimeTotal)*self.msPerBeat/self.ticksPerBeat)
                 else:
                     msTotal = (event.deltaTime/self.ticksPerSecond)*.001
-                #add event to trackData
+                # add event to trackData
                 deltaTimeTotal = nextTotal
                 event.setStartTime(msTotal)
                 trackData.addEvent(event)
             self.tracks.append(trackData)
 
     def getNumTracks(self):
         return len(self.tracks)
+
     def getTrack(self, index):
         return self.tracks[index]
+
+
+class UnexpectedEventException(Exception):
+    def __init__(self, event, expectedEvent):
+        self.event = event
+        self.expectedEvent = expectedEvent
+
+    def __str__(self):
+        return str("MidiData expected event of type " + str(type(self.expectedEvent))
+                   + ", got event of type " + str(type(self.event)))
+
+
+class NotSupportedException(Exception):
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return str(self.value)

MidiEventDecoder.py

@@ -2,41 +2,47 @@
 from MidiEvents import *
 from Util import Util
 
-#decodes data from the MidiParser into data easier to work with in MidiData
-#(will decode each piece of data from midiParser into an event,
-#including header chunk pieces)
+
+# decodes data from the MidiParser into data easier to work with in MidiData
+# (will decode each piece of data from midiParser into an event,
+# including header chunk pieces)
 class MidiEventDecoder:
     def __init__(self, midiFilename):
         self.midiParser = MidiParser(midiFilename)
         self.runningStatus = False
+        self.lastChannelStatusByte = None  # the first byte of the last channel event that didn't use running status
         return
+
     def hasMoreEvents(self):
         return self.midiParser.hasMoreData()
-    #be sure to call this once before calling nextEvent
+    # be sure to call this once before calling nextEvent
+
     def headerData(self):
         data = HeaderData()
         data.setFromBytes(self.midiParser.readNextData(),
                           self.midiParser.readNextData())
         return data
-    #returns a MidiEvent
+
+    # returns a MidiEvent
     def nextEvent(self):
         return self.midiEvent(self.midiParser.readNextData())
-    #creates a MidiEvent from the midiData
+    # creates a MidiEvent from the midiData
+
     def midiEvent(self, midiData):
-        #check if TrackHeader
+        # check if TrackHeader
         if midiData[0:4] == b'MTrk':
             trackHeader = TrackHeader()
             trackHeader.setFromBytes(midiData)
             return trackHeader
-        #find deltaTime
+        # find deltaTime
         tempData = midiData
-        temp = 0
-        while Util.msbIsOne(tempData[temp:]):
-            temp = temp+1
-        temp = temp + 1
-        deltaTime = tempData[:temp]
-        midiData = tempData[temp:]
-        #Meta Event
+        deltaTimeBytesLength = 0
+        while Util.msbIsOne(tempData[deltaTimeBytesLength:]):
+            deltaTimeBytesLength += 1
+        deltaTimeBytesLength += 1
+        deltaTime = tempData[:deltaTimeBytesLength]
+        midiData = tempData[deltaTimeBytesLength:]
+        # Meta Event
         if midiData[0:1] == b'\xff':
             if midiData[1] in EventDictionaries.META_EVENT_DICTIONARY:
                 metaEventClass = EventDictionaries.META_EVENT_DICTIONARY[midiData[1]]
@@ -46,26 +52,27 @@ def midiEvent(self, midiData):
             metaEvent.setDeltaTimeFromBytes(deltaTime)
             metaEvent.setFromBytes(midiData)
             return metaEvent
-        #System Event
+        # System Event
         if midiData[0:1] == b'\xf0' or midiData[0:1] == b'\xf7':
             systemEvent = SystemExclusiveEvent()
             systemEvent.setDeltaTimeFromBytes(deltaTime)
             systemEvent.setFromBytes(midiData)
             return systemEvent
-        #Channel Event
-        if Util.msbIsOne(midiData): #running status
+        # Channel Event
+        if Util.msbIsOne(midiData):  # running status
             self.lastChannelStatusByte = midiData[0]
-        else: #not running status
+        else:  # not running status
             midiData = self.lastChannelStatusByte + midiData
-        channelEventIdentifier = midiData[0] & int('f0',16)
-        if (channelEventIdentifier in EventDictionaries.CHANNEL_EVENT_DICTIONARY):
+        channelEventIdentifier = midiData[0] & int('f0', 16)
+        if channelEventIdentifier in EventDictionaries.CHANNEL_EVENT_DICTIONARY:
             channelEventClass = EventDictionaries.CHANNEL_EVENT_DICTIONARY[channelEventIdentifier]
         else:
             channelEventClass = ChannelEvent
         channelEvent = channelEventClass()
         channelEvent.setDeltaTimeFromBytes(deltaTime)
         channelEvent.setFromBytes(midiData)
         return channelEvent
+
     def close(self):
         self.midiParser.close()