mpclient: get rid of CamelCase in private functions.

1 files changed, 68 insertions, 69 deletions

diff --git a/nephilim/mpclient.py b/nephilim/mpclient.py
index 5f60094..291ae05 100644
--- a/nephilim/mpclient.py
+++ b/nephilim/mpclient.py
@@ -11,20 +11,21 @@ class MPClient(QtCore.QObject):
     _listeners = None    # array of listeners: { event: (listeners)* }
 
     # cached objects
-    _curLib      = None
-    _curPlaylist = None
-    _curSong     = None
+    _cur_lib      = None
+    _cur_playlist = None
+    _cur_song     = None
 
     # objects used for comparison with previous value
-    _curSongID    = None
-    _curTime      = None
-    _curState     = None
-    _curVolume    = None
+    _cur_songid   = None
+    _cur_time     = None
+    _cur_state    = None
+    _cur_volume   = None
     _updatings_db = None
     _cur_plist_id = None
 
-    _timerID = None
+    _timer_id = None
 
+    _retr_mutex = QtCore.QMutex()
 
     events = {
         'beforeSongChange':'curSongID',
@@ -45,12 +46,12 @@ class MPClient(QtCore.QObject):
         self._client    = None
         self._listeners = {}
 
-        self._curSongID    = -1
-        self._curTime      = -1
-        self._curState     = -1
-        self._curVolume    = -1
-        self._curLib       = []
-        self._curPlaylist  = []
+        self._cur_songid    = -1
+        self._cur_time      = -1
+        self._cur_state     = -1
+        self._cur_volume    = -1
+        self._cur_lib       = []
+        self._cur_playlist  = []
         self._cur_plist_id = -1
 
         for event in self.events:
@@ -69,10 +70,10 @@ class MPClient(QtCore.QObject):
 
         self._raiseEvent('onConnect', None)
 
-        self._updateLib()
-        self._updatePlaylist()
-        self._updateCurrentSong()
-        self._timerID = self.startTimer(500)
+        self._update_lib()
+        self._update_playlist()
+        self._update_current_song()
+        self._timer_id = self.startTimer(500)
 
         self._raiseEvent('onStateChange', {'oldState':'stop', 'newState':self.getStatus()['state']})
         self._raiseEvent('onReady', None)
@@ -93,19 +94,19 @@ class MPClient(QtCore.QObject):
         """Returns the current playlist."""
         if not self.isConnected():
             return []
-        return self._curPlaylist
+        return self._cur_playlist
 
     def listLibrary(self):
         """Returns current library."""
         if not self.isConnected():
             return []
-        return self._curLib
+        return self._cur_lib
 
     def getCurrentSong(self):
         """Returns the current playing song."""
         if not self.isConnected():
             return None
-        return self._curSong
+        return self._cur_song
 
     def updateDB(self, paths = None):
         """Starts MPD database update."""
@@ -162,19 +163,6 @@ class MPClient(QtCore.QObject):
             val = 1 if val else 0
         self._client.random(val)
 
-    _retrMutex = QtCore.QMutex()
-    def _retrieve(self, method):
-        """Makes sure only one call is made at a time to MPD."""
-        self._retrMutex.lock()
-        try:
-            ret = method()
-        except socket.error:
-            self._retrMutex.unlock()
-            self._client = None
-            return None
-
-        self._retrMutex.unlock()
-        return ret
 
     def isPlaying(self):
         """Returns True if MPD is playing, False otherwise."""
@@ -197,7 +185,7 @@ class MPClient(QtCore.QObject):
     def next(self):
         """Move on to the next song in the playlist."""
         self._playCalled = False
-        self._raiseEvent('beforeSongChange', {'curSongID': self._curSongID})
+        self._raiseEvent('beforeSongChange', {'curSongID': self._cur_songid})
         # we only switch to the next song, if some of beforeSongChange's listeners
         # didn't explicitly call play. If it did, then it ain't good to immediatly
         # skip to the next song!
@@ -212,8 +200,8 @@ class MPClient(QtCore.QObject):
 
     def seek(self, time):
         """Seek to time."""
-        if self._curSongID > 0:
-            self._client.seekid(self._curSongID, time)
+        if self._cur_songid > 0:
+            self._client.seekid(self._cur_songid, time)
 
     def deleteFromPlaylist(self, list):
         """Remove all song IDs in list from the playlist."""
@@ -221,11 +209,11 @@ class MPClient(QtCore.QObject):
         for id in list:
             self._client.deleteid(id)
         self._client.command_list_end()
-        self._updatePlaylist()
+        self._update_playlist()
     def clear_playlist(self):
         """Clear current playlist."""
         self._client.clear()
-        self._updatePlaylist()
+        self._update_playlist()
 
     def addToPlaylist(self, paths):
         """Add all files in paths to the current playlist."""
@@ -234,8 +222,8 @@ class MPClient(QtCore.QObject):
             for path in paths:
                 self._client.addid(path.encode('utf-8'))
             ret = self._client.command_list_end()
-            self._updatePlaylist()
-            if self._curState == 'stop':
+            self._update_playlist()
+            if self._cur_state == 'stop':
                 self.play(ret[0])
         except mpd.CommandError:
             logging.error('Cannot add some files, check permissions.')
@@ -258,33 +246,44 @@ class MPClient(QtCore.QObject):
             raise Exception("Unknown event "+event)
         self._listeners[event].remove(callback)
 
+    def _retrieve(self, method):
+        """Makes sure only one call is made at a time to MPD."""
+        self._retr_mutex.lock()
+        try:
+            ret = method()
+        except socket.error:
+            self._retr_mutex.unlock()
+            self._client = None
+            return None
 
-    def _updateLib(self):
+        self._retr_mutex.unlock()
+        return ret
+    def _update_lib(self):
         """Update the cached library."""
-        self._curLib = self._arrayToSongArray(self._retrieve(self._client.listallinfo))
+        self._cur_lib = self._array_to_song_array(self._retrieve(self._client.listallinfo))
         id = 0
-        for song in self._curLib:
+        for song in self._cur_lib:
             song._data['id'] = id
             id += 1
-    def _updatePlaylist(self):
+    def _update_playlist(self):
         """Update the cached playlist."""
-        self._curPlaylist = self._arrayToSongArray(self._retrieve(self._client.playlistinfo))
-    def _arrayToSongArray(self, array):
+        self._cur_playlist = self._array_to_song_array(self._retrieve(self._client.playlistinfo))
+    def _array_to_song_array(self, array):
         """Convert an array to an array of Songs."""
         return map(lambda entry: Song(entry)
             , filter(lambda entry: not('directory' in entry), array)
             )
-    def _updateCurrentSong(self):
+    def _update_current_song(self):
         """Update the current song."""
         song = self._retrieve(self._client.currentsong)
         if not song:
-            self._curSong = None
+            self._cur_song = None
         else:
-            self._curSong = Song(song)
+            self._cur_song = Song(song)
 
-    class simpleThread(Thread):
+    class SimpleThread(Thread):
         callback = None
-        params = None
+        params   = None
         def __init__(self,callback,params):
             Thread.__init__(self)
             self.callback = callback
@@ -298,7 +297,7 @@ class MPClient(QtCore.QObject):
             raise Exception("Unknown raised event "+event)
 
         for listener in self._listeners[event]:
-            self.simpleThread(listener, params).run()
+            self.SimpleThread(listener, params).run()
 
     def timerEvent(self, event):
         """Check for changes since last check."""
@@ -307,48 +306,48 @@ class MPClient(QtCore.QObject):
         if status == None:
             self._client = None
             self._raiseEvent('onDisconnect', None)
-            self.killTimer(self._timerID)
+            self.killTimer(self._timer_id)
             return
 
-        self._updateCurrentSong()
+        self._update_current_song()
         " check if song has changed"
-        song = self._curSong
+        song = self._cur_song
         if song:
             curID = song.getID()
         else:
             curID = -1
 
-        if curID != self._curSongID:
-            self._raiseEvent('onSongChange', {'oldSongID':self._curSongID, 'newSongID':curID})
-            self._curSongID = curID
+        if curID != self._cur_songid:
+            self._raiseEvent('onSongChange', {'oldSongID':self._cur_songid, 'newSongID':curID})
+            self._cur_songid = curID
 
         " check if the time has changed"
         if 'time' in status:
             curTime = status['time']
-            if curTime!=self._curTime:
-                self._raiseEvent('onTimeChange', {'oldTime':self._curTime, 'newTime':curTime})
-                self._curTime = curTime
+            if curTime!=self._cur_time:
+                self._raiseEvent('onTimeChange', {'oldTime':self._cur_time, 'newTime':curTime})
+                self._cur_time = curTime
             if curTime>=status['length']-1:
                 self._raiseEvent('beforeSongChange', {'curSongID':curID})
 
         " check if the playing state has changed"
         if 'state' in status:
             curState = status['state']
-            if curState!=self._curState:
-                self._raiseEvent('onStateChange', {'oldState':self._curState, 'newState':curState})
-                self._curState = curState
+            if curState!=self._cur_state:
+                self._raiseEvent('onStateChange', {'oldState':self._cur_state, 'newState':curState})
+                self._cur_state = curState
 
         " check if the volume has changed"
         if 'volume' in status:
             curVolume = int(status['volume'])
-            if curVolume!=self._curVolume:
-                self._raiseEvent('onVolumeChange', {'oldVolume':self._curVolume, 'newVolume':curVolume})
-                self._curVolume = curVolume
+            if curVolume!=self._cur_volume:
+                self._raiseEvent('onVolumeChange', {'oldVolume':self._cur_volume, 'newVolume':curVolume})
+                self._cur_volume = curVolume
 
         if 'playlist' in status:
             cur_plist_id = int(status['playlist'])
             if cur_plist_id != self._cur_plist_id:
-                self._updatePlaylist()
+                self._update_playlist()
                 self._raiseEvent('onPlaylistChange', None)
                 self._cur_plist_id = cur_plist_id