def getNextSong(self):
try:
fileName = self.songSource.nextSong() # get next song filename
self.fd = open(fileName, 'rb')
self.file_size = os.path.getsize(fileName)
# if there is valid ID3 data, read it out of the file first,
# so we can skip sending it to the client
try:
self.id3 = id3reader.Reader(self.fd)
if isinstance(
self.id3.header.size, int
) and self.id3.header.size < self.file_size: # read out the id3 data
self.fd.seek(self.id3.header.size + 1, os.SEEK_SET)
log.debug("Reading %d bytes of ID3: %d",
self.id3.header.size, self.fd.tell())
except id3reader.Id3Error:
self.id3 = None
self.metadata = self.make_metadata()
except StopIteration:
fileName = None
self.fd = None
except IOError:
self.fd = None
log.debug("getting next song: %s", fileName)
def GetTrackInfo(filePath):
global pauseOnError
global pauseOnUnicode
global found
global tagError
global lengthError
global unicodeError
global filePathError
global corruptError
global windowsError5
global windowsError
length = 0
title = ""
artist = ""
album = ""
genre = ""
# Construct a reader from a file or filename.
id3r = id3reader.Reader(filePath)
try:
op = 'retrieving length'
f = codecs.open(filePath, 'rb')
i = MP3Info.MP3Info(f)
# length = i.mpeg.total_time
length = i.mpeg.length
op = 'retrieving title'
title = id3r.getValue(u'title')
op = 'retrieving artist'
artist = id3r.getValue(u'performer')
op = 'retrieving album'
album = id3r.getValue(u'album')
op = 'retrieving genre'
genre = id3r.getValue(u'genre')
except UnicodeEncodeError:
unicodeError = unicodeError + 1
try:
print "Error with Unicode in %s while %s" % (filePath, op)
if pauseOnUnicode == 'true':
raw_input("Press ENTER to continue...")
except UnicodeEncodeError:
print " unprintable filename"
if pauseOnUnicode == 'true':
raw_input("Press ENTER to continue...")
except:
try:
if op == 'retrieving length':
lengthError = lengthError + 1
print "Unhandled Exception in %s while %s" % (filePath, op)
if pauseOnError == 'true':
raw_input("Press ENTER to continue...")
except UnicodeEncodeError:
unicodeError = unicodeError + 1
print " unprintable filename"
if pauseOnError == 'true':
raw_input("Press ENTER to continue...")
return length, title, artist, album, genre
def print_mp3_file_details(mp3_filename):
id3r = id3reader.Reader(mp3_filename)
print mp3_filename
print "album: " + str(id3r.getValue('album'))
print "performer: " + str(id3r.getValue('performer'))
print "title: " + str(id3r.getValue('title'))
print "year: " + str(id3r.getValue('year'))
print hashlib.sha256(open(mp3_filename, "r").read()).hexdigest()[0:16]
def _getID3Name(self, old_name):
id3r = id3reader.Reader(old_name)
track_number = id3r.getValue('track') or "0"
track_number = track_number.split("/")[0]
title = id3r.getValue('title') or "No title"
title = title.strip()
return self.to_ascii("%s %s.mp3" % (track_number.zfill(2), title))
def useId3reader(self, songPath):
id3r = id3reader.Reader(songPath)
print self.info
if id3r.getValue("title"):
self.info["name"] = id3r.getValue("title")
if id3r.getValue("performer"):
self.info["singer"] = id3r.getValue("performer")
if id3r.getValue("album"):
self.info["album"] = id3r.getValue("album")
def extract_year(s, files):
directory_name = s
years = [int(s) for s in s.split() if s.isdigit() and len(s) == 4]
if len(years) > 0:
return min(years)
else:
for file in files:
if file.endswith("mp3") or file.endswith("wma"):
id3r = id3reader.Reader("%s/%s" % (directory_name, file))
if id3r.getValue('year'):
return id3r.getValue('year')
def extract_artist(s, files):
directory_name = s
artist_name = s.split("-")
if len(artist_name) > 0:
return artist_name[0].split("/")[-1]
else:
for file in files:
if file.endswith("mp3") or file.endswith("wma"):
id3r = id3reader.Reader("%s/%s" % (directory_name, file))
if id3r.getValue('artist'):
return id3r.getValue('artist')
def _getID3Name(self, old_name):
id3r = id3reader.Reader(old_name)
separador = "-"
track_artist = id3r.getValue('performer')
track_artist = track_artist
title = id3r.getValue('title') or "No title"
title = title.strip()
track_artist = replace_illegal_chars(track_artist)
title = replace_illegal_chars(title)
return self.to_ascii("%s %s %s.mp3" % (track_artist, separador, title))
def extract_album(s, files):
directory_name = s
artist_name = s.split("-")
if len(artist_name) > 0:
return artist_name[-1].replace(" (Forró em vinil)", "").replace(
" (forró em vinil)", "").replace(" (forro em vinil)", "").strip()
else:
for file in files:
if file.endswith("mp3") or file.endswith("wma"):
id3r = id3reader.Reader("%s/%s" % (directory_name, file))
if id3r.getValue('album'):
return id3r.getValue('album')
def id3_sort_key(mp3_path):
"""Create the sort key for an MP3 file.
"""
id3r = id3reader.Reader(mp3_path)
return (
get_value(id3r, 'performer'),
get_value(id3r, 'year'),
get_value(id3r, 'album'),
get_track(id3r),
get_value(id3r, 'title'),
# Provide the original path as a fallback for MP3s with missing or non-unique ID3 tags.
mp3_path,
)
def __init__(self, file):
self.title = self.artist = self.track = self.year = \
self.comment = self.composer = self.album = \
self.disc = self.genre = self.encoder = None
id3 = id3reader.Reader(file)
if id3 and id3.frames and id3.frames != {}:
self.title = id3.getValue('title')
self.artist = id3.getValue('artist')
self.track = id3.getValue('track')
self.year = id3.getValue('year')
self.comment = id3.getValue('comment')
self.album = id3.getValue('album')
self.genre = id3.getValue('genre')
if self.genre and self.genre[0] == '(' and self.genre[-1] == ')':
genres = self.num_regex.findall(self.genre)
if len(genres) > 0:
try:
# Force to single value even if multiple
self.genre = id3reader.genres[int(genres[0])]
except IndexError:
self.genre = ""
else:
self.genre = ""
self.composer = id3.getValue('composer')
self.disc = id3.getValue('disc')
self.encoder = id3.getValue('encoder')
mpeg = None
if id3 and id3.header and id3.header.majorVersion and id3.header.majorVersion >= 2:
# ID3v2 size (header_size) doesn't include 10 bytes of header
mpeg = MPEG(file, seekstart=id3.header.size+10)
else:
# Header better be near the beginning if there is no ID3v2
mpeg = MPEG(file)
if mpeg:
if mpeg.total_time > 0:
self.total_time = mpeg.total_time
self.filesize = mpeg.filesize2
self.bitrate = int(mpeg.bitrate)
self.samplerate = mpeg.samplerate/1000
self.mode = mpeg.mode
self.mode_extension = mpeg.mode_extension
else:
self.total_time = 0
self.filesize = mpeg.filesize2
self.bitrate = "unknown"
self.samplerate = "unknown"
self.mode = ""
self.mode_extension = ""
def ScanMusic(songTitle='', performer='', album='', directory='./music'):
# Use OS to access input directory
os.chdir(directory)
# Read all files from designated music directory
mp3Files = []
for localFile in glob.glob("*.mp3"):
mp3Data = id3reader.Reader(localFile)
mp3Files.append({
'file': localFile,
'title': str(mp3Data.getValue('title')),
'artist': str(mp3Data.getValue('performer')),
'album': str(mp3Data.getValue('album'))
})
if (len(mp3Files) == 0):
return []
# If no parameters were specified, choose a random song
if (songTitle == '' and performer == '' and album == ''):
index = random.randint(0, len(mp3Files) - 1)
return [mp3Files[index]]
# Filter all songs that don't match designated title
if (songTitle != ''):
for entry in mp3Files:
if (entry['title'].lower() != songTitle.lower()):
mp3Files.remove(entry)
# Filter all songs that don't match designated artist
if (performer != ''):
for entry in mp3Files:
if (entry['artist'].lower() != performer.lower()):
mp3Files.remove(entry)
# Filter all songs that don't match designated album
if (album != ''):
for entry in mp3Files:
if (entry['album'].lower() != album.lower()):
mp3Files.remove(entry)
# Remove all repeated files
for entry in mp3Files:
for entry2 in mp3Files:
if (entry2 != entry and entry['title'] == entry2['title']
and entry['artist'] == entry2['artist']
and entry['album'] == entry2['album']):
mp3Files.remove(entry2)
return mp3Files
def getTags(path):
try:
id3r = id3reader.Reader(path)
song_info = {}
song_info['Artist'] = id3r.getValue('performer')
song_info['Album'] = id3r.getValue('album')
song_info['Title'] = id3r.getValue('title')
song_info['ReleaseDate'] = id3r.getValue('year')
if song_info['Title']:
music_data.append(song_info)
except:
print 'error',
def get_meta(self, fp):
def decode_string(tag):
for encoding in ['cp1251', 'utf-8', 'MacCyrillic']:
try:
return tag.decode(encoding)
except UnicodeDecodeError:
continue
else:
encoding = chardet.detect(tag)['encoding']
try:
tag = tag.decode(encoding)
except UnicodeDecodeError:
return None
else:
return tag
def decode_unicode(tag):
try:
tag = tag.encode('latin1')
except UnicodeEncodeError:
pass
else:
tag = decode_string(tag)
return tag
def convert(tag):
if isinstance(tag, str):
return decode_string(tag)
elif isinstance(tag, unicode):
return decode_unicode(tag)
else:
None
try:
id3r = id3reader.Reader(fp)
except:
log.info("Cannot read meta tag")
return
artist = convert(id3r.getValue('performer') or '')
title = convert(id3r.getValue('title') or '')
if artist and title:
return {"artist": artist, "title": title}
else:
log.error("Bad meta tags '%s'-'%s'" % (artist, title))
return None
def searchForLovedSongs(searchForLovedSongs):
path = raw_input("Enter the path to your music folder: ")
if not os.path.exists(path):
while True:
path = raw_input(
"The folder specified does not exist. Enter the path to your music folder: "
)
if not os.path.exists(path):
break
destination = raw_input(
"Enter the path to destination folder (the loved songs will be copyied there): "
)
makePathOk(destination)
filelist = parse_dirs(path)
print "There were " + str(len(filelist)) + " files found"
print "Please wait while the songs are verified (it might take a while)"
for filename in filelist:
if filename[-4:] == ".mp3":
try:
id3r = id3reader.Reader(filename)
except UnicodeDecodeError:
artist = "None"
title = "None"
except IOError:
artist = "None"
title = "None"
else:
artist = ensureutf8andstring(id3r.getValue('performer'))
title = ensureutf8andstring(id3r.getValue('title'))
if artist != "None" or title != "None":
if lovedSongs[artist][title] == 1:
try:
shutil.copy(filename, destination)
except:
print '"' + artist + ' - ' + title + '" could not be copied'
else:
print '"' + artist + ' - ' + title + '" was successfully copied'
print "parsing done"
def getTags(path):
try:
id3r = id3reader.Reader(path)
song_info = {}
song_info['Title'] = id3r.getValue('title')
song_info['Artist'] = id3r.getValue('performer')
song_info['Album'] = id3r.getValue('album')
year = id3r.getValue('year')
y = re.match(r'(?<!\d)\d{4,7}(?!\d)', year)
song_info['ReleaseYear'] = y.group(0)
song_info['Genre'] = id3r.getValue('genre')
song_info['Filename'] = path.split('/')[-1]
song_info['Folder'] = path.split('/')[-2]
if song_info['Title']:
music_data.append(song_info)
except:
pass
def generate(path):
import id3reader
import guidem.model
if os.access(path, os.R_OK):
print 'Access granted'
for root, dirs, files in os.walk(path):
root = os.path.join(os.getcwd(), root)
for fname in files:
file = open(os.path.join(root, fname), 'rb')
contentlength = os.stat(os.path.join(root, fname)).st_size
try:
id3r = id3reader.Reader(file)
except:
continue
artist = (id3r.getValue('performer') or '').decode('cp1251')
title = (id3r.getValue('title') or '').decode('cp1251')
composition = (id3r.getValue('album') or '').decode('cp1251')
no = id3r.getValue('track') or None
no = int(no.split('/')[0]) if no else None
if artist and title:
file = guidem.model.File(
fname.decode('utf-8'),
os.path.join(root, fname).decode('utf-8'),
contentlength).db_add()
if file:
artist = guidem.model.Artist.get_or_add(artist)
if composition and no:
track = guidem.model.Track(title, artist, file.id, \
composition=composition, no=no).db_add()
else:
track = guidem.model.Track(title, artist,
file.id).db_add()
if track:
print 'Track %s - %s added.' % (artist, track)
else:
print 'Track not added.'
else:
print "Cannot add file: '%s'" % fname
print 'Database generated'
else:
print 'Access denied'
def getM3uString(fname):
mp3file = open(fname, 'rb')
caption, performer, title = '', '', ''
try:
mp3file.seek(0)
id3 = id3reader.Reader(mp3file)
performer = id3.getValue('performer')
title = id3.getValue('title')
except:
safeprint("Couldn't read ID3 tag in file %s: %s" %
(fname, formatException()))
if performer:
caption += performer
if title:
if caption:
caption += ' - '
caption += title
extinf = ''
if caption:
secs = 0
try:
mp3file.seek(0)
secs = mp3secs(mp3file)
except:
safeprint("Couldn't read MP3 file %s: %s" %
(fname, formatException()))
if isinstance(caption, type(u'')):
caption = caption.encode('iso8859-1', 'replace')
extinf = '#EXTINF:%d,%s\n' % (int(secs), caption)
mp3file.close()
fpath = fname.abspath()
if isinstance(fpath, type(u'')):
fpath = fpath.encode('iso8859-1', 'replace')
return extinf + fpath + '\n'
def getTrack():
try:
f = open(__PIPE)
try:
lines = f.read().strip().split('\n')
finally:
f.close()
except IOError:
# nothing to read
pass
else:
k, v = lines[-1].split(':', 1)
fileName = v.strip()
# check, if "filename" is real file -- sometimes it can be URL!
if os.path.isfile(fileName):
id3 = id3reader.Reader(fileName)
performer = id3.getValue('performer')
title = id3.getValue('title')
if not None in (performer, title):
return (performer, title)
def rename(src, is_numbering=False, n=None):
try:
logger.info("Path exists")
id3r = id3reader.Reader(src)
artist = id3r.getValue("performer")
title = id3r.getValue("title")
if artist is None or title is None:
return None
if is_numbering and n != None:
filename = "%02d %s - %s" % (n, artist,
title) + os.path.splitext(src)[1]
else:
filename = "%s - %s" % (artist, title) + os.path.splitext(src)[1]
logger.info("New filename: " + filename)
return sanitize(filename) if artist and title else src
except:
return None
def main():
parser = argparse.ArgumentParser(
description='Sorts music into Artist/Album/01 - Song Title.mp3 like structures')
parser.add_argument('-s', '--source', dest='source_dir', required=True,
help='Source directory (with the unsorted music in it)')
parser.add_argument('-d', '--destination',
dest='destination_dir', required=True,
help='Destination directory (where the sorted music goes)')
args = parser.parse_args()
for directory in os.walk(args.source_dir):
for _file in directory[2]:
_file = join(directory[0], _file)
try:
reader = id3reader.Reader(_file)
except IOError:
continue
if not reader.getValue('performer'):
print 'ERROR: skipping %s' % _file
continue
artist_album = os.path.join(args.destination_dir,
reader.getValue('performer'),
reader.getValue('album'))
track = reader.getValue('track')
if '/' in track:
track = track.split('/')[0]
if len(track) == 1:
track = '0%s' % track
new_file_name = '%s - %s.mp3' % (
track, reader.getValue('title').replace('/', ','))
new_file_path = join(artist_album, new_file_name)
if exists(new_file_path):
continue
try:
os.makedirs(artist_album)
except OSError:
pass
shutil.copy2(_file, new_file_path)
print 'Made: %s' % os.path.join(artist_album, new_file_name)
def handleMP3(fpath, fname):
"""
This function is called every time we identify a new MP3 file. It handles reading the ID3 tag and then adding the file to the appropriate playlists.
"""
global playlist_ALL
global playlist_dir
global MP3_ROOT
global PLAYLIST_ROOT
# TODO: This is a hack because MPlayer doesn't give us what we need.
# Read the rest of the information from the file directly, since MPlayer isn't telling us
absolutePath = MP3_ROOT + fpath # this is the actual (absolute path)
try:
id3r = id3reader.Reader(os.path.join(absolutePath, fname))
#print "reading ID3 from "+os.path.join(absolutePath, fname) # DEBUG
# Ask the reader for ID3 values:
title = id3r.getValue('title')
artist = id3r.getValue('performer')
album = id3r.getValue('album')
genre = id3r.getValue('genre')
#displayName = artist+" - "+title+" ("+album+")"
displayName = ""
if artist != None:
displayName = displayName + artist + " - "
if title != None:
displayName = displayName + title
if album != None:
displayName = displayName + " (" + album + ")"
except id3reader.Id3Error, message:
print "file " + absolutePath + "/" + fname + " Id3Error: ", message
displayName = fname
title = ""
artist = ""
album = ""
genre = ""
def FromPath(self, path, attemptparse=True):
"""Rehydrate a track from its path."""
new_track = False
updated = False
id_row = self.db.GetOneRow(
'select track_id from paths where path = "%s";' % path)
if id_row:
id = id_row['track_id']
self.persistant = self.db.GetOneRow(
'select * from tracks where id=%d;' % id)
if not self.persistant:
raise Exception('No persistant data for track id: %s' % id)
# There was a bug a while ago where we left underscores in the database.
# Clean that up...
for key in 'artist', 'album', 'song':
if not key in self.persistant:
raise Exception(
'Required key %s missing for track path %s' %
(key, path))
before = self.persistant[key]
after = self.persistant[key].replace('_', ' ')
if before != after:
self.persistant[key] = after
updated = True
else:
# This is a new track
self.persistant = {}
self.persistant['creation_time'] = datetime.datetime.now()
new_track = True
# Attempt to parse the path using Mikal's file naming scheme. 30 chars is
# is the field length for ID3, and might indicate the tags have been
# truncated
if attemptparse:
if (not 'artist' in self.persistant
or len(self.persistant.get('song', ' ')) == 30
or len(self.persistant.get('album', ' ')) == 30):
m = _PATH_PARSE_RE.match(path)
if m:
try:
self.persistant['artist'] = m.group(1).replace(
'_', ' ')
self.persistant['album'] = m.group(2).replace('_', ' ')
self.persistant['song'] = m.group(4).replace('_', ' ')
self.persistant['number'] = int(m.group(3)).replace(
'_', ' ')
updated = True
except:
pass
# Use ID3 if we're missing information. This isn't as good as file parsing
# as the ID3 fields have maximum lengths we sometimes hit.
if not self.persistant.has_key('artist'):
try:
id3r = id3reader.Reader(path)
if id3r.getValue('album'):
self.persistant['album'] = id3r.getValue('album')
updated = True
if id3r.getValue('performer'):
self.persistant['artist'] = id3r.getValue('performer')
updated = True
if id3r.getValue('title'):
self.persistant['song'] = id3r.getValue('title')
updated = True
if id3r.getValue('track'):
try:
self.persistant['number'] = int(id3r.getValue('track'))
updated = True
except:
pass
except:
pass
# Perhaps we have this MP3 under another path
if not self.persistant.has_key('artist'):
try:
self.FromMeta(self.persistant['artist'],
self.persistant['album'],
self.persistant['number'],
self.persistant['song'])
updated = True
except:
pass
if new_track:
# Now write this to the database to get an ID
self.db.ExecuteSql(
'insert into tracks(artist, album, song, number) '
'values(%s, %s, %s, %d);' %
(sql.FormatSqlValue('artist', self.persistant['artist']),
sql.FormatSqlValue('album', self.persistant['album']),
sql.FormatSqlValue('song', self.persistant['song']),
self.persistant.get('number', 0)))
id = self.db.GetOneRow(
'select last_insert_id();')['last_insert_id()']
self.persistant['id'] = id
if updated:
print 'Updated track %s' % self.persistant['id']
self.Store()
msvcrt.setmode(1, os.O_BINARY) # stdout = 1
except ImportError:
pass
form = cgi.FieldStorage()
# holds the file
fileitem = form['file']
if fileitem.filename:
fn = os.path.basename(fileitem.filename)
open('./audio/' + fn, 'wb').write(fileitem.file.read())
db = MySQLdb.connect(host="localhost", user="******", passwd="3308", db="RT")
cur = db.cursor()
id3 = id3reader.Reader('./audio/' + fn)
cur.execute(
"INSERT INTO tracks (Title, Artist, Album, FileName) VALUES ('" +
id3.getValue('title') + "','" + id3.getValue('performer') + "','" +
id3.getValue('album') + "','" + fn + "');")
db.close()
message = 'The file was uploaded successfully.'
else:
message = 'No file was uploaded'
print """\
Content-Type: text/html\n
<html>
<head>
files.sort()
# recurse into subdirs
for dir in dirs:
results = process_dir(dir, results=results, coverFiles=coverFiles)
# continue processing this dir once subdirs have been processed
log.debug("evaluating " + thisDir)
# if any of the given cover files exist, no further work required
for coverFile in coverFiles:
if coverFile in files:
log.debug("cover file %s exists - skipping" % coverFile)
return results
for file in files:
fileFullPath = os.path.join(thisDir, file)
# check file for id3 tag info
try:
id3r = id3reader.Reader(fileFullPath)
except Exception, err:
log.error('exception: ' + str(err))
continue
# get values and sanitise nulls
artist = id3r.getValue('performer')
album = id3r.getValue('album')
if artist == None: artist = ''
if album == None: album = ''
# if either artist or album found, append to results and return
if artist or album:
log.info("album details found: %s/%s in %s" % (artist, album, file))
results.append((thisDir, artist, album))
return results
# no artist or album info found, return results unchanged
return results
def get_track(music_file):
id3r = id3reader.Reader(music_file)
track = int(id3r.getValue('track'))
return track
def realread(self):
fileread = self.fileread
#print str(self) + str(oop)+str(fileread)
print fileread
if str(fileread).endswith(".mp3"):
cmd = [
os.environ.get('SUGAR_BUNDLE_PATH') + "/bin/mpg123",
str(fileread)
]
else:
cmd = [
os.environ.get('SUGAR_BUNDLE_PATH') + "/bin/mpg123", "-@",
str(fileread)
]
#print "playing "+ str(fileread)
self._is_jornal = "yes"
self._playingjnl = str(fileread)
subprocess.Popen(cmd)
if str(fileread).endswith(".pls"):
id3, err = subprocess.Popen([
"/bin/sh", "-c",
"cat " + str(fileread) + " | grep Title1= | cut -d '=' -f2"
],
stdout=subprocess.PIPE).communicate()
elif str(fileread).endswith(".mp3"):
id3r = id3reader.Reader(str(fileread))
id3 = "Title: " + str(id3r.getValue('title')) + "\nArtist: " + str(
id3r.getValue('performer')) + "\nAlbum: " + str(
id3r.getValue('album')) + ""
#print id3
#id3=id3.capitalize()
else:
id3tmp, err = subprocess.Popen(
["/bin/sh", "-c", "cat " + str(fileread)],
stdout=subprocess.PIPE).communicate()
id3 = "M3U stream at " + id3tmp + ""
#print "id3 is "+str(id3)
if id3 == "":
id3 = "Unknown"
self.play_button.connect('clicked', self._stop)
self.play_button.set_icon_widget(self.pause_image)
self.play_button.set_tooltip(_('Stop'))
self.box_playing.remove(self.label_playing_url)
self.label_playing_url = gtk.Label(str(id3))
self.label_playing_url.set_justify(gtk.JUSTIFY_CENTER)
self.label_playing_url.set_line_wrap(True)
self.label_playing_url.modify_font(pango.FontDescription("Sans 14"))
self.box_playing.add(self.label_playing_url)
self.label_title.set_text(_("Now Playing"))
if fileread.endswith('.mp3'):
id3title = str(id3r.getValue('performer')) + " - " + str(
id3r.getValue('title'))
else:
id3title = id3
print id3title
print fileread
# not quite working... doesnt update after 1st song!
#self.set_title("Now Playing:\n"+str(id3title)) =
self.show_all()
def parseFilename(filename):
#check out id3 for recently downloaded files
origfilename = filename
id3r = id3reader.Reader(sourceDir + filename)
filename = id3r.getValue('title')
log_info("Filename:: " + origfilename + "; Parsed to:: " + filename)
def MyID3(self, fileLoc):
# Create a scrollable container
self.scroll = ScrollView(do_scroll_x=(False))
# Asign the directory to a variable
self.musicDirectory = fileLoc
# Create a grid background to allign the buttons
self.gridLayer = GridLayout(cols=1, size_hint=(1, None))
# Size fix for grid
self.gridLayer.bind(minimum_height=self.gridLayer.setter('height'),
minimum_width=self.gridLayer.setter('width'))
# Add the grid widget to the scroller
self.scroll.add_widget(self.gridLayer)
# Artist label
self.artist = Label()
# Song label
self.song = Label()
# Album label
self.album = Label()
# Begin the alternating count to alternate the background images (see bellow)
self.alternate = 1
# Process each file in the targeted directory
for file in os.listdir(self.musicDirectory):
# Check if the file is an MP3
if file.endswith(".mp3"):
# Run ID3 Reader to gather the ID3 data
id3r = id3reader.Reader(self.musicDirectory + file)
# Try to gather the artist ID3 data
try:
self.artist.text = self.stripSquare(
id3r.getValue('performer'))
except:
self.artist.text = "Not Found"
# Try to gather the song title ID3 data
try:
self.song.text = self.stripSquare(id3r.getValue('title'))
except:
self.song.text = "Not Found"
# Try to gather the album ID3 data
try:
self.album.text = self.stripSquare(id3r.getValue('album'))
except:
self.album.text = "Not Found"
# Create a spawn of the music button class
self.temp = MusicButton(text="testing",
halign="center",
size_hint=(1, None),
height=("80dp"),
background_normal='images/listone.png',
background_down='images/bk.png',
markup=True)
# Set the music buttons filename attribute
self.temp.musicFileName = file
# Alternate the background colours
if self.alternate % 2 == 0:
self.temp.background_normal = 'images/listtwo.png'
self.alternate += 1
# Shorten the Ssong title to prevent overflow.
self.song.text = self.song.text[:30] + (self.song.text[30:]
and '..')
# Format the music button text
self.temp.text = "[anchor=title1][size=18sp][color=#4D5158]" + self.song.text + "[/color][/size]\n[color=#AAAAAA]" + self.artist.text + "[/color]"
self.gridLayer.add_widget(self.temp)
# Link the button press and release to events
self.temp.bind(on_press=self.songSelect,
on_release=self.songRelease)
# Return the newly created window
return self.scroll
import id3reader
import os
import shutil
filename=""
flag=0
src ='E:\musiq'
#C:\Users\TMZ\Music
songs = []
with open("database.txt","w") as c:
for root, dirs, files in os.walk(src):
for f in files:
list =[]
filename = os.path.join(root, f)
if filename.endswith('.mp3'):
#print filename
id3r = id3reader.Reader(filename)
try:
if str(id3r.getValue('title'))!= "None" and str(id3r.getValue('performer'))!="None" and str(id3r.getValue('album'))!="None" and str(id3r.getValue('year'))!="None" and str(id3r.getValue('genre')) !="None":
list.append(str(id3r.getValue('title')))
list.append(str(id3r.getValue('performer')))
list.append(str(id3r.getValue('album')))
list.append(str(id3r.getValue('year')))
list.append(str(id3r.getValue('genre')))
dest = "E:\songs\\" + f
shutil.copy(filename,dest)
except:
print filename
else:
#print list
if list not in songs:
songs.append(list)
