Change variables and methods to python style

Author: Cornerback24

MidiData.py

@@ -6,85 +6,85 @@
 
 # contains the finalized data after analysis
 class MidiData:
-    def __init__(self, midiFilename, middle_c="C4"):
-        self.eventDecoder = MidiEventDecoder(midiFilename)
-        headerData = self.eventDecoder.headerData()
+    def __init__(self, midi_filename, middle_c="C4"):
+        self.event_decoder = MidiEventDecoder(midi_filename)
+        header_data = self.event_decoder.header_data()
         # variables
-        self.format = headerData.formatType
-        self.numTracks = headerData.numTracks
-        self.isTicksPerBeat = False
+        self.format = header_data.format_type
+        self.num_tracks = header_data.num_tracks
+        self.is_ticks_per_beat = False
         self.middle_c = middle_c
-        if headerData.ticksPerBeat is None:
-            self.isTicksPerBeat = False
-            self.ticksPerSecond = (headerData.framesPerSecond *
-                                   headerData.ticksPerFrame)
+        if header_data.ticks_per_beat is None:
+            self.is_ticks_per_beat = False
+            self.ticks_per_second = (header_data.frames_per_second *
+                                     header_data.ticks_per_frame)
         else:
-            self.isTicksPerBeat = True
-            self.ticksPerBeat = headerData.ticksPerBeat
+            self.is_ticks_per_beat = True
+            self.ticks_per_beat = header_data.ticks_per_beat
 
-        if headerData.formatType != 1 and headerData.formatType != 0:
-            raise NotSupportedException("Midi files of format " + str(headerData.formatType)
+        if header_data.format_type != 1 and header_data.format_type != 0:
+            raise NotSupportedException("Midi files of format " + str(header_data.format_type)
                                         + " are not supported")
 
         # maps running total of delta times to microsecondsPerQuarter
-        tempoChanges = TempoChanges()
+        tempo_changes = TempoChanges()
         self.tracks = []
 
-        self.msPerBeat = 500  # default 120 bpm
+        self.ms_per_beat = 500  # default 120 bpm
 
         # read in each track
         tracknum = 0  # used to create temporary track names
-        while self.eventDecoder.hasMoreEvents():
-            trackName = "Track" + str(tracknum)
+        while self.event_decoder.has_more_events():
+            track_name = "Track" + str(tracknum)
             tracknum += 1
-            trackData = TrackData(name=trackName, middle_c=self.middle_c)
+            track_data = TrackData(name=track_name, middle_c=self.middle_c)
             # should be a track header
-            event = self.eventDecoder.nextEvent()
+            event = self.event_decoder.next_event()
             if not (isinstance(event, TrackHeader)):
                 raise UnexpectedEventException(event, TrackHeader())
-            # set up tempoChanges
-            tempoChanges.reset()
-            self.msPerBeat = 500  # default 120 bpm
-            deltaTimeTotal = 0  # current time in ticks
-            msTotal = 0  # current time in ms
+            # set up tempo_changes
+            tempo_changes.reset()
+            self.ms_per_beat = 500  # default 120 bpm
+            delta_time_total = 0  # current time in ticks
+            ms_total = 0  # current time in ms
             # add events
             while not (isinstance(event, EndOfTrackEvent)):
-                event = self.eventDecoder.nextEvent()
+                event = self.event_decoder.next_event()
                 if isinstance(event, SetTempoEvent):
-                    tempoChanges.addTempoChange(deltaTimeTotal, event.tempo)
-                nextTotal = deltaTimeTotal + event.deltaTime
+                    tempo_changes.add_tempo_change(delta_time_total, event.tempo)
+                next_total = delta_time_total + event.delta_time
                 # calculate absolute start time for event in ms
-                if self.isTicksPerBeat:
-                    while (tempoChanges.hasMore() and
-                           nextTotal >= tempoChanges.deltaTimeTotal()):
-                        msTotal += ((tempoChanges.deltaTimeTotal() - deltaTimeTotal)*self.msPerBeat/self.ticksPerBeat)
-                        deltaTimeTotal = tempoChanges.deltaTimeTotal()
-                        self.msPerBeat = tempoChanges.usPerQuarter() * .001
-                        tempoChanges.findNext()
-                    msTotal += ((nextTotal - deltaTimeTotal) * self.msPerBeat / self.ticksPerBeat)
+                if self.is_ticks_per_beat:
+                    while (tempo_changes.has_more() and
+                           next_total >= tempo_changes.delta_time_total()):
+                        ms_total += ((tempo_changes.delta_time_total() - delta_time_total) * self.ms_per_beat / self.ticks_per_beat)
+                        delta_time_total = tempo_changes.delta_time_total()
+                        self.ms_per_beat = tempo_changes.us_per_quarter() * .001
+                        tempo_changes.find_next()
+                    ms_total += ((next_total - delta_time_total) * self.ms_per_beat / self.ticks_per_beat)
                 else:
-                    msTotal = (event.deltaTime / self.ticksPerSecond) * .001
-                # add event to trackData
-                deltaTimeTotal = nextTotal
-                event.setStartTimeMs(msTotal)
-                event.setStartTimeTicks(deltaTimeTotal)
-                trackData.addEvent(event)
-            self.tracks.append(trackData)
+                    ms_total = (event.delta_time / self.ticks_per_second) * .001
+                # add event to track_data
+                delta_time_total = next_total
+                event.set_start_time_ms(ms_total)
+                event.set_start_time_ticks(delta_time_total)
+                track_data.add_event(event)
+            self.tracks.append(track_data)
 
-    def getNumTracks(self):
+    def get_num_tracks(self):
         return len(self.tracks)
 
-    def getTrack(self, index):
+    def get_track(self, index):
         return self.tracks[index]
 
 
 class UnexpectedEventException(Exception):
-    def __init__(self, event, expectedEvent):
+    def __init__(self, event, expected_event):
         self.event = event
-        self.expectedEvent = expectedEvent
+        self.expected_event = expected_event
 
     def __str__(self):
-        return str("MidiData expected event of type " + str(type(self.expectedEvent))
+        return str("MidiData expected event of type " + str(type(self.expected_event))
                    + ", got event of type " + str(type(self.event)))
 
 

MidiEventDecoder.py

@@ -4,74 +4,74 @@
 
 
 # decodes data from the MidiParser into data easier to work with in MidiData
-# (will decode each piece of data from midiParser into an event,
+# (will decode each piece of data from midi_parser 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
+    def __init__(self, midi_filename):
+        self.midi_parser = MidiParser(midi_filename)
+        self.running_status = False
+        self.last_channel_status_byte = None  # the first byte of the last channel event that didn't use running status
         return
 
-    def hasMoreEvents(self):
-        return self.midiParser.hasMoreData()
+    def has_more_events(self):
+        return self.midi_parser.has_more_data()
 
-    # be sure to call this once before calling nextEvent
-    def headerData(self):
+    # be sure to call this once before calling next_event
+    def header_data(self):
         data = HeaderData()
-        data.setFromBytes(self.midiParser.readNextData(),
-                          self.midiParser.readNextData())
+        data.set_from_bytes(self.midi_parser.read_next_data(),
+                            self.midi_parser.read_next_data())
         return data
 
     # returns a MidiEvent
-    def nextEvent(self):
-        return self.midiEvent(self.midiParser.readNextData())
-    # creates a MidiEvent from the midiData
+    def next_event(self):
+        return self.midi_event(self.midi_parser.read_next_data())
+    # creates a MidiEvent from the midi_data
 
-    def midiEvent(self, midiData):
+    def midi_event(self, midi_data):
         # check if TrackHeader
-        if midiData[0:4] == b'MTrk':
-            trackHeader = TrackHeader()
-            trackHeader.setFromBytes(midiData)
-            return trackHeader
-        # find deltaTime
-        tempData = midiData
-        deltaTimeBytesLength = 0
-        while Util.msbIsOne(tempData[deltaTimeBytesLength:]):
-            deltaTimeBytesLength += 1
-        deltaTimeBytesLength += 1
-        deltaTime = tempData[:deltaTimeBytesLength]
-        midiData = tempData[deltaTimeBytesLength:]
+        if midi_data[0:4] == b'MTrk':
+            track_header = TrackHeader()
+            track_header.set_from_bytes(midi_data)
+            return track_header
+        # find delta_time
+        temp_data = midi_data
+        delta_time_bytes_length = 0
+        while Util.msb_is_one(temp_data[delta_time_bytes_length:]):
+            delta_time_bytes_length += 1
+        delta_time_bytes_length += 1
+        delta_time = temp_data[:delta_time_bytes_length]
+        midi_data = temp_data[delta_time_bytes_length:]
         # Meta Event
-        if midiData[0:1] == b'\xff':
-            if midiData[1] in EventDictionaries.META_EVENT_DICTIONARY:
-                metaEventClass = EventDictionaries.META_EVENT_DICTIONARY[midiData[1]]
+        if midi_data[0:1] == b'\xff':
+            if midi_data[1] in EventDictionaries.META_EVENT_DICTIONARY:
+                meta_event_class = EventDictionaries.META_EVENT_DICTIONARY[midi_data[1]]
             else:
-                metaEventClass = MetaEvent
-            metaEvent = metaEventClass()
-            metaEvent.setDeltaTimeFromBytes(deltaTime)
-            metaEvent.setFromBytes(midiData)
-            return metaEvent
+                meta_event_class = MetaEvent
+            meta_event = meta_event_class()
+            meta_event.set_delta_time_from_bytes(delta_time)
+            meta_event.set_from_bytes(midi_data)
+            return meta_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
+        if midi_data[0:1] == b'\xf0' or midi_data[0:1] == b'\xf7':
+            system_event = SystemExclusiveEvent()
+            system_event.set_delta_time_from_bytes(delta_time)
+            system_event.set_from_bytes(midi_data)
+            return system_event
         # Channel Event
-        if Util.msbIsOne(midiData):  # running status
-            self.lastChannelStatusByte = midiData[0:1]
+        if Util.msb_is_one(midi_data):  # running status
+            self.last_channel_status_byte = midi_data[0:1]
         else:  # not running status
-            midiData = self.lastChannelStatusByte + midiData
-        channelEventIdentifier = midiData[0] & int('f0', 16)
-        if channelEventIdentifier in EventDictionaries.CHANNEL_EVENT_DICTIONARY:
-            channelEventClass = EventDictionaries.CHANNEL_EVENT_DICTIONARY[channelEventIdentifier]
+            midi_data = self.last_channel_status_byte + midi_data
+        channel_event_identifier = midi_data[0] & int('f0', 16)
+        if channel_event_identifier in EventDictionaries.CHANNEL_EVENT_DICTIONARY:
+            channel_event_class = EventDictionaries.CHANNEL_EVENT_DICTIONARY[channel_event_identifier]
         else:
-            channelEventClass = ChannelEvent
-        channelEvent = channelEventClass()
-        channelEvent.setDeltaTimeFromBytes(deltaTime)
-        channelEvent.setFromBytes(midiData)
-        return channelEvent
+            channel_event_class = ChannelEvent
+        channel_event = channel_event_class()
+        channel_event.set_delta_time_from_bytes(delta_time)
+        channel_event.set_from_bytes(midi_data)
+        return channel_event
 
     def close(self):
-        self.midiParser.close()
+        self.midi_parser.close()