1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
|
#!/usr/bin/env python2
# -*- coding: utf-8-*-
import re
import difflib
from mpd import MPDClient
def reconnect(func, *default_args, **default_kwargs):
"""
Reconnects before running
"""
def wrap(self, *default_args, **default_kwargs):
try:
self.client.connect("localhost", 6600)
except:
pass
# sometimes not enough to just connect
try:
func(self, *default_args, **default_kwargs)
except:
self.client = MPDClient()
self.client.timeout = None
self.client.idletimeout = None
self.client.connect("localhost", 6600)
func(self, *default_args, **default_kwargs)
return wrap
class Song:
def __init__(self, id, title, artist, album):
self.id = id
self.title = title
self.artist = artist
self.album = album
class Music:
client = None
songs = [] # may have duplicates
playlists = []
# capitalized strings
song_titles = []
song_artists = []
def __init__(self):
"""
Prepare the client and music variables
"""
# prepare client
self.client = MPDClient()
self.client.timeout = None
self.client.idletimeout = None
self.client.connect("localhost", 6600)
# gather playlists
self.playlists = [x["playlist"] for x in self.client.listplaylists()]
# gather songs
self.client.clear()
for playlist in self.playlists:
self.client.load(playlist)
soup = self.client.playlist()
for i in range(0, len(soup) / 10):
index = i * 10
id = soup[index].strip()
title = soup[index + 3].strip().upper()
artist = soup[index + 2].strip().upper()
album = soup[index + 4].strip().upper()
self.songs.append(Song(id, title, artist, album))
self.song_titles.append(title)
self.song_artists.append(artist)
@reconnect
def play(self, songs=False, playlist_name=False):
"""
Plays the current song or accepts a song to play.
Arguments:
songs -- a list of song objects
playlist_name -- user-defined, something like "Love Song Playlist"
"""
if songs:
self.client.clear()
for song in songs:
try: # for some reason, certain ids don't work
self.client.add(song.id)
except:
pass
if playlist_name:
self.client.clear()
self.client.load(playlist_name)
self.client.play()
#@reconnect -- this makes the function return None for some reason!
def current_song(self):
item = self.client.playlistinfo(int(self.client.status()["song"]))[0]
result = "%s by %s" % (item["title"], item["artist"])
return result
@reconnect
def volume(self, level=None, interval=None):
if level:
self.client.setvol(int(level))
return
if interval:
level = int(self.client.status()['volume']) + int(interval)
self.client.setvol(int(level))
return
@reconnect
def pause(self):
self.client.pause()
@reconnect
def stop(self):
self.client.stop()
@reconnect
def next(self):
self.client.next()
return
@reconnect
def previous(self):
self.client.previous()
return
def get_soup(self):
"""
returns the list of unique words that comprise song and artist titles
"""
soup = []
for song in self.songs:
song_words = song.title.split(" ")
artist_words = song.artist.split(" ")
soup.extend(song_words)
soup.extend(artist_words)
title_trans = ''.join(
chr(c) if chr(c).isupper() or chr(c).islower() else '_' for c in range(256))
soup = [x.decode('utf-8').encode("ascii", "ignore").upper().translate(title_trans).replace("_", "")
for x in soup]
soup = [x for x in soup if x != ""]
return list(set(soup))
def get_soup_playlist(self):
"""
returns the list of unique words that comprise playlist names
"""
soup = []
for name in self.playlists:
soup.extend(name.split(" "))
title_trans = ''.join(
chr(c) if chr(c).isupper() or chr(c).islower() else '_' for c in range(256))
soup = [x.decode('utf-8').encode("ascii", "ignore").upper().translate(title_trans).replace("_", "")
for x in soup]
soup = [x for x in soup if x != ""]
return list(set(soup))
def get_soup_separated(self):
"""
returns the list of PHRASES that comprise song and artist titles
"""
title_soup = [song.title for song in self.songs]
artist_soup = [song.artist for song in self.songs]
soup = list(set(title_soup + artist_soup))
title_trans = ''.join(
chr(c) if chr(c).isupper() or chr(c).islower() else '_' for c in range(256))
soup = [x.decode('utf-8').encode("ascii", "ignore").upper().translate(title_trans).replace("_", " ")
for x in soup]
soup = [re.sub(' +', ' ', x) for x in soup if x != ""]
return soup
def fuzzy_songs(self, query):
"""
Returns songs matching a query best as possible on either artist field, etc
"""
query = query.upper()
matched_song_titles = difflib.get_close_matches(
query, self.song_titles)
matched_song_artists = difflib.get_close_matches(
query, self.song_artists)
# if query is beautifully matched, then forget about everything else
strict_priority_title = [x for x in matched_song_titles if x == query]
strict_priority_artists = [
x for x in matched_song_artists if x == query]
if strict_priority_title:
matched_song_titles = strict_priority_title
if strict_priority_artists:
matched_song_artists = strict_priority_artists
matched_songs_bytitle = [
song for song in self.songs if song.title in matched_song_titles]
matched_songs_byartist = [
song for song in self.songs if song.artist in matched_song_artists]
matches = list(set(matched_songs_bytitle + matched_songs_byartist))
return matches
def fuzzy_playlists(self, query):
"""
returns playlist names that match query best as possible
"""
query = query.upper()
lookup = {n.upper(): n for n in self.playlists}
results = [lookup[r] for r in difflib.get_close_matches(query, lookup)]
return results
if __name__ == "__main__":
"""
Plays music and performs unit-testing
"""
print "Creating client"
music = Music()
print "Playing"
music.play(songs=[music.songs[3]])
print music.get_soup_separated()
while True:
query = raw_input("Query: ")
songs = music.fuzzy_songs(query)
print "Results"
print "======="
for song in songs:
print "Title: %s Artist: %s" % (song.title, song.artist)
music.play(songs=songs)
|
