def getMetaData(fullname, playlists):
    log.info('accessing metadata...')
    index = 0
    tagInfo = []
    for track in playlists:
        name= playlists[track]
        if os.path.isfile(name):
            try:
                filename = os.path.basename(name)
                log.success('-------------------------')
                tag = TinyTag.get(name)
                if tag.title != '' or tag.artist != '':
                    song = str(tag.title+':'+tag.artist)
                    tagInfo.append(song)
                    log.warn('tag info:', filename.encode("ascii", "ignore"))
                    log.info('Artist:', tag.artist)
                    log.info('Album:', tag.album)
                    log.info('Title:', tag.title.encode("ascii", "ignore"))
                    log.info('Track number:', tag.track)
                    index += 1
                else:
                    log.warn('WARN: no id3 info provide')

            except Exception as e:
                log.err("An error occurred while getting metadata of the file:", name)
                log.err("Error:", e)
        else:
            log.err("The file: %s does not exist, check the path or filename" % (name))
    print
    log.err('track processing:', str(index))
    saveMetaData(fullname, tagInfo, index)
    return tagInfo

def main():
    args = parser.parse_args()
    args.foldername = os.path.expanduser(args.foldername)
    new_foldername = args.foldername
    # keep a list of all cues and flacs
    file_lists = get_music(new_foldername=new_foldername)
    music_filenames = file_lists['mp3']
    # now, for each file, get the mp3 tags and get the date created
    music_dataframe = []
    for music_file in music_filenames:
        try:
            tag = TinyTag.get(music_file)
        except Exception as e:
            print e
            next
        if tag.artist is not None:
            artist = tag.artist.encode('ascii', 'ignore')
        if tag.album is not None:
            album = tag.album.encode('ascii', 'ignore')
        if tag.title is not None:
            title = tag.title.encode('ascii', 'ignore')
        date_changed = os.path.getmtime(music_file)
        music_dataframe.append({'artist':artist,'album':album,'title':title,'date':date_changed})


    music_dataframe = DataFrame(music_dataframe)
    music_dataframe.to_csv("mp3_tags.csv")

def db_check():
        mp3s = get_mp3_list()
        for d, mp3 in mp3s:
                fullpath = os.path.join(d,mp3)
                data = db_get(fullpath, 'fullpath')
                if not data:
                        print 'adding: ', fullpath
                        data = {
                                'fullpath': fullpath,
                                'title': mp3,
                                'description': '',
                        }
                        try:
                                date_part = mp3.split('.')[0]
                                date_obj = datetime.strptime(date_part, '%Y-%m-%d_%H-%M-%S')
                                #data['date'] = datetime.strftime(date_obj, '%a %b %d, %Y at %I:%M %p')
                                data['date'] = date_obj
                        except:
                                date_obj = datetime.fromtimestamp(os.path.getctime(fullpath))
                                #data['date'] = datetime.strftime(date_obj, '%a %b %d, %Y at %I:%M %p')
                                data['date'] = date_obj
                        tag = TinyTag.get(fullpath)
                        m, s = divmod(tag.duration, 60)
                        h, m = divmod(m, 60)
                        data['duration'] = "%d:%02d:%02d" % (h, m, s)
                        db_insert(data)
        delete = []
        for mp3 in db_get_all():
                if not os.path.exists(mp3['fullpath']):
                        delete.append(mp3['fullpath'])
        for d in delete:
                print 'removing: ', d
                db_remove(d)

 def folderTraversal(self, folderPath):
     for root, subdir, files in os.walk(folderPath):
         hasMusic = False
         albumName = ""
         for f in files:
             fullPath = os.path.join(root, f)
             try:
                 metadata = TinyTag.get(fullPath)
             except LookupError:
                 # File is not a valid audio file, skip
                 continue
             metadata.album = str(metadata.album)
             self.trackIDList.add(utils.genID(metadata))
             if self.config.filter.check(metadata) and not (metadata in self.record):
                 albumName = metadata.album
                 if albumName not in self.albums:
                     self.albums[albumName] = objects.Album(albumName)
                 newTrack = objects.Track(metadata, fullPath)
                 self.albums[albumName].add(newTrack)
                 hasMusic = True
                 self.progress.incTotal()
         if hasMusic:
             # Handle cover image
             self.albums[albumName].coverFile = self.__detectCoverFile(root)
             logging.info("Album: %s with %d song(s)" %
                          (albumName, len(self.albums[albumName].tracks)))

def getSongInfo(filepath):
    tag = TinyTag.get(filepath)
    # make sure everthing returned (except length) is a string
    for attribute in ['artist','album','title','track']:
        if getattr(tag, attribute) is None:
            setattr(tag, attribute, '')
    return Metainfo(tag.artist, tag.album, tag.title, str(tag.track), tag.length)

 def test_duration_with_vlc(self):
     import vlc
     v = vlc.Instance()
     mp = MusicPlayer(self.config)
     albums = mp.get_albums_and_songs()
     # VLC Start
     start_time = time.time()
     for album in albums:
         print(colorstring("Album: " + album.title, Colors.GREEN))
         for song in album.getsonglist():
             print(colorstring("\t" + str(song.title), Colors.BLUE))
             media = v.media_new(song.filepath)
             media.parse()
             print("\tsong duration: " + str(media.get_duration()))
     print(colorstring("--- VLC took %s seconds ---" % round((time.time() - start_time), 5), Colors.RED))
     # VLC End
     # TinyTag Start
     start_time = time.time()
     for album in albums:
         print(colorstring("Album: " + album.title, Colors.GREEN))
         for song in album.getsonglist():
             print(colorstring("\t" + str(song.title), Colors.BLUE))
             tinytag = TinyTag.get(song.filepath, False, True)
             print("\tsong duration: " + str(round(tinytag.duration * 1000)))
     print(colorstring("--- TinyTag took %s seconds ---" % round((time.time() - start_time), 5), Colors.RED))

 def _fetch_embedded_image(self, path):
     filetypes = ('.mp3',)
     max_tries = 3
     header, data, resized = None, '', False
     try:
         files = os.listdir(path)
         files = (f for f in files if f.lower().endswith(filetypes))
         for count, file_in_dir in enumerate(files, start=1):
             if count > max_tries:
                 break
             filepath = os.path.join(path, file_in_dir)
             try:
                 tag = TinyTag.get(filepath, image=True)
                 image_data = tag.get_image()
             except IOError:
                 continue
             if not image_data:
                 continue
             _header, _data = self.resize_image_data(
                 image_data, (self.IMAGE_SIZE, self.IMAGE_SIZE))
             if _data:
                 header, data, resized = _header, _data, True
                 break
     except OSError:
         pass
     return header, data, resized

    def api_fetchalbumart(self, directory):
        _save_and_release_session()
        default_folder_image = "../res/img/folder.png"

        log.i('Fetching album art for: %s' % directory)
        filepath = os.path.join(cherry.config['media.basedir'], directory)

        if os.path.isfile(filepath):
            # if the given path is a file, try to get the image from ID3
            tag = TinyTag.get(filepath, image=True)
            image_data = tag.get_image()
            if image_data:
                log.d('Image found in tag.')
                header = {'Content-Type': 'image/jpg', 'Content-Length': len(image_data)}
                cherrypy.response.headers.update(header)
                return image_data
            else:
                # if the file does not contain an image, display the image of the
                # parent directory
                directory = os.path.dirname(directory)

        #try getting a cached album art image
        b64imgpath = albumArtFilePath(directory)
        img_data = self.albumartcache_load(b64imgpath)
        if img_data:
            cherrypy.response.headers["Content-Length"] = len(img_data)
            return img_data

        #try getting album art inside local folder
        fetcher = albumartfetcher.AlbumArtFetcher()
        localpath = os.path.join(cherry.config['media.basedir'], directory)
        header, data, resized = fetcher.fetchLocal(localpath)

        if header:
            if resized:
                #cache resized image for next time
                self.albumartcache_save(b64imgpath, data)
            cherrypy.response.headers.update(header)
            return data
        elif cherry.config['media.fetch_album_art']:
            #fetch album art from online source
            try:
                foldername = os.path.basename(directory)
                keywords = foldername
                log.i(_("Fetching album art for keywords {keywords!r}").format(keywords=keywords))
                header, data = fetcher.fetch(keywords)
                if header:
                    cherrypy.response.headers.update(header)
                    self.albumartcache_save(b64imgpath, data)
                    return data
                else:
                    # albumart fetcher failed, so we serve a standard image
                    raise cherrypy.HTTPRedirect(default_folder_image, 302)
            except:
                # albumart fetcher threw exception, so we serve a standard image
                raise cherrypy.HTTPRedirect(default_folder_image, 302)
        else:
            # no local album art found, online fetching deactivated, show default
            raise cherrypy.HTTPRedirect(default_folder_image, 302)

def test_pathlib_compatibility():
    try:
        import pathlib
    except ImportError:
        return
    testfile = next(iter(testfiles.keys()))
    filename = pathlib.Path(testfolder) / testfile
    tag = TinyTag.get(filename)

def get_node(filename):
    from tinytag import TinyTag

    logger.debug(filename)
    try:
        tag = TinyTag.get(filename)
        logger.info(tag.title)
    except LookupError as err:
        logger.error("File `{0}` processing error: {1}".format(filename, err))

	def __init__(self, ruta, titulo = "Cancion desconocida", artista = "Autor desconocido"):
		self.ruta = ruta
		datos = TinyTag.get(ruta)
		self.artista = artista
		self.titulo = titulo
		if datos.title:
			self.titulo = datos.title
		if datos.artist:
			self.artista = datos.artist

def genMoodHist(fileName, inputFile, outputFile, localOutput):
    countsR = initCounts()
    countsG = initCounts()
    countsB = initCounts()

    while True:
        byte = inputFile.read(3)
        if len(byte) == 3:
            countsR[int(ord(byte[0]) / 23)] += 1
            countsG[int(ord(byte[1]) / 23)] += 1
            countsB[int(ord(byte[2]) / 23)] += 1
        else:
            break

    for binIdx in range(12):
        xMin = binIdx * 23
        xMax = xMin + 22
        localOutput.write(str(xMin) + "-" + str(xMax) + ";")
    localOutput.write("\n")

    writeHist(countsR, localOutput)
    writeHist(countsG, localOutput)
    writeHist(countsB, localOutput)

    try:
        tag = TinyTag.get(fileName[:-5] + ".mp3")
        if tag.bitrate < 512:
            br = int(round(tag.bitrate))
        else:
            br = int(round(tag.bitrate/1000))

        outputFile.write(fileName + ";" +
                         str(br) + ";")

        table = []
        ct = 0;
        with open(fileName[:-5] + ".csv", 'r') as fd:
            for line in fd:
                table.append(line.strip().split(";"))
                ct += 1;
            for i in range(0,3):
                subtotal = float(0)
                for rgb in table:
                    subtotal += pow(int(rgb[i]), 2)
                subtotal /= ct
                outputFile.write(str(subtotal) + ";")

        outputFile.write(str(getCountsMax(countsR)) + ";" +
                         str(getCountsMax(countsG)) + ";" +
                         str(getCountsMax(countsB)) + "\n")

    except OSError as ose:
        print("Error: " + str(ose))
        return (1)

    return (0)

def getTag(song_path): #returns all matching fields
    tag = TinyTag.get(song_path)
    tag_fields = tag.__dict__
    details = {}
    for item in tag_fields:
        if item in fields and tag_fields[item] != None:
            details[item] = tag_fields[item]
    details['duration'] = "{:.2f}".format(details.get('duration'))
    if details.get('bitrate') > 5000:
        details.pop('bitrate')
    return details

def get_info(testfile, expected):
    filename = os.path.join(samplefolder, testfile)
    print(filename)
    tag = TinyTag.get(filename)
    for key, value in expected.items():
        result = getattr(tag, key)
        fmt_string = 'field "%s": got %s (%s) expected %s (%s)!'
        fmt_values = (key, repr(result), type(result), repr(value), type(value))
        assert result == value, fmt_string % fmt_values
    print(tag)
    print(tag.__repr__())

def tags_wav(name, infer=True):
    try:
        tags = TinyTag.get(name)
    except struct.error:
        if infer:
            uprint('WARN: Corrupted or mistagged, inferring artist and album: %s ...' % name, end=' ')
            return infer_album_artist(name)
        return None
    if not tags:
        return None, None
    return tags.artist, tags.album

def get_artist(path):
    musicMeta = TinyTag.get(path)
    artist = musicMeta.artist
    
    if artist is not None:
        artist = ''.join(i for i in artist if i not in string.punctuation).replace(" ", "")
        
    if artist is None or not artist or artist.isspace():
        return "Unknown"
    else:
        return artist

 def __init__(self, title: str, filepath: str):
     super(SongModel, self).__init__()
     self.id = id(self)
     self.title = title
     self.filepath = filepath
     # This operation can go wrong when another program is using the filepath
     try:
         self._tags = TinyTag.get(self.filepath, False, True)
         self.duration = round(self._tags.duration)
     except PermissionError as e:
         self.duration = None
         print(e)

def moves_record():
    """-"""
    input_file = "../audio/show1/01_m.mp3"
    tag = TinyTag.get(input_file)
    track_length = tag.duration
    if os.path.exists(input_file + ".moves"):
        os.remove(input_file + ".moves")
    output_file = open(input_file + ".moves", "w")

    pygame.init()
    pygame.mixer.init()
    pygame.mixer.music.load(input_file)

    print "Playing " + input_file
    print "3... "
    time.sleep(1)
    print "2... "
    time.sleep(1)
    print "1... "
    time.sleep(1)

    pygame.mixer.music.play()
    start_time = time.time()
    last_time = 0
    is_done = False
    do_extra_close = False
    create_output(output_file, '{ "moveitem": [')
    while (is_done != True) and ((time.time() - start_time) < track_length):
        command = ""
        next_char = getch()
        current_time = time.time() - start_time
        if do_extra_close:
            create_output(
                output_file, str('   { "time":%.2f, "command":"%s" },' % ((current_time + last_time) / 2, "CLOSE"))
            )
            do_extra_close = False
        if next_char == "q":
            is_done = True
        else:
            if next_char == "i":  # This means OPEN_THEN_CLOSE
                command = "OPEN"
                do_extra_close = True
            if next_char == "o":
                command = "OPEN"
            if next_char == "p":
                command = "CLOSE"
            if command != "":
                create_output(output_file, str('   { "time":%.2f, "command":"%s" },' % (current_time, command)))
        last_time = current_time
    create_output(output_file, str('   { "time":%.2f, "command":"CLOSE" }\n] }' % track_length))
    output_file.close()

def copland_scrape():
    event_list = Event.objects.filter(start_date__gt=date(2013, 11, 22)).order_by('start_date')
    event_list = event_list.reverse()
    text_file = open("copland.txt", "w")
    fstring = ""
    for e in event_list:
	print(e.name)
        fstring += e.start_date.strftime("%m.%d.%y") + ": " + e.name
        program = Program.objects.select_related().filter(event = e).order_by('position')
        performers = Performer.objects.select_related().filter(event = e).order_by('position')
        recs = EventAudioRecording.objects.select_related().filter(event = e).order_by('position')
        dur = ""
	for i in range(len(program)):
            work = program[i].works.all()[0]
            if len(recs) > 0 and os.path.isfile(recs[i].compressed_master_recording.path):
                #mf = mad.MadFile(recs[i].compressed_master_recording.path)
                #dur = int(mf.total_time() / 1000)
                #dur = str(timedelta(seconds=dur))
		#fname = recs[i].uncompressed_master_recording.path
		#print(fname)
		#with contextlib.closing(wave.open(fname,'r')) as f:
		#    frames = f.getnframes()
    		#    rate = f.getframerate()
    		#    duration = math.floor(frames / float(rate))
		#    minutes, seconds = divmod(duration, 60)
		#    hours, minutes = divmod(minutes, 60)
		#    dur = str(hours) + ":" + str(minutes) + ":" + str(seconds)
		tag = TinyTag.get(recs[i].compressed_master_recording.path)
		duration = tag.duration
		print(duration)
		minutes, seconds = divmod(duration, 60)
                hours, minutes = divmod(minutes, 60)
                dur = str(int(hours)) + ":" + str(int(minutes)) + ":" + str(int(seconds))

            else:
                dur = "????"
            fstring += "\n"+work.name + " by " + work.authors.all()[0].name + "* - " + dur
        if len(performers) > 0:
            fstring += "\nperformers: "
            for p in performers:
                fstring += p.performer.name + " - "
                for i in p.instruments.all():
                    fstring += i.name + ", "
                fstring = fstring[:-2]
                fstring += "; "
            fstring = fstring[:-2]
        fstring += "\n\n"
    text_file.write(fstring.encode('utf-8'))
    text_file.close()

def get_encode_task(source_file, destination, bitrate):
    tags = TinyTag.get(source_file)
    track_relative_path = get_track_relative_path(tags)

    if track_relative_path:
        track_absolute_path = os.path.join(destination, track_relative_path)
        if not os.path.exists(track_absolute_path):
            return {
                'source': source_file,
                'destination': track_absolute_path,
                'destination_rel': track_relative_path,
                'bitrate': bitrate
            }
    else:
        print('Ignoring ' + source_file)