def test_two_invalid(tmpdir):
    """Test when two FLAC files have invalid tags."""
    flac_dir = tmpdir.mkdir('flac')
    flac_files = []
    # One.
    flac = flac_dir.join('Artist2 - 202 - Album - 01 - Title.flac').ensure(file=True)
    with open(os.path.join(os.path.dirname(__file__), '1khz_sine.flac'), 'rb') as f:
        flac.write(f.read(), 'wb')
    tags = FLAC(str(flac.realpath()))
    tags.update(dict(artist='Artist2', date='2012', album='Album', tracknumber='01', title='Title'))
    tags.save()
    flac_files.append(str(flac.realpath()))
    # Two.
    flac = flac_dir.join('Artist - 2014 - Album - 01 - Title.flac').ensure(file=True)
    with open(os.path.join(os.path.dirname(__file__), '1khz_sine.flac'), 'rb') as f:
        flac.write(f.read(), 'wb')
    tags = FLAC(str(flac.realpath()))
    tags.update(dict(artist='Artist2', date='2014', album='Album', tracknumber='01', title='Title'))
    tags.save()
    flac_files.append(str(flac.realpath()))
    # Test.
    a_messages = find_inconsistent_tags(flac_files, True, True)
    e_messages = {
        flac_files[0]: ["Filename date not four digits."],
        flac_files[1]: ["Artist mismatch: Artist != Artist2"],
    }
    assert e_messages == a_messages

def test_one_valid_two_invalid(tmpdir):
    """Test when one FLAC file is fully valid and another one isn't."""
    flac_dir = tmpdir.mkdir('flac')
    flac_files = []
    # Valid.
    flac = flac_dir.join('Artist2 - 2012 - Album - 01 - Title.flac').ensure(file=True)
    with open(os.path.join(os.path.dirname(__file__), '1khz_sine.flac'), 'rb') as f:
        flac.write(f.read(), 'wb')
    tags = FLAC(str(flac.realpath()))
    tags.update(dict(artist='Artist2', date='2012', album='Album', tracknumber='01', title='Title'))
    tags.save()
    flac_files.append(str(flac.realpath()))
    # Invalid.
    flac = flac_dir.join('Artist - 2014 - Album - 01 - Title.flac').ensure(file=True)
    with open(os.path.join(os.path.dirname(__file__), '1khz_sine.flac'), 'rb') as f:
        flac.write(f.read(), 'wb')
    tags = FLAC(str(flac.realpath()))
    tags.update(dict(artist='Artist2', date='2014', album='Album', tracknumber='01', title='Title'))
    tags.save()
    flac_files.append(str(flac.realpath()))
    # Test.
    a_messages = find_inconsistent_tags(flac_files, True, True)
    e_messages = {flac_files[1]: [
        "Artist mismatch: Artist != Artist2",
    ]}
    assert e_messages == a_messages

class Id3tool:
    ''' class to read/write mp3 tags '''

    def __init__(self, fn):
        ''' allow throw if file not supported '''

        if fnmatch.fnmatch(fn, '*.ogg'):
            self.tag_obj = OggVorbis(fn)

        elif fnmatch.fnmatch(fn, '*.flac'):
            self.tag_obj = FLAC(fn)

        else:
            self.tag_obj = EasyID3(fn)

    def save(self):
        self.tag_obj.save()

    def readTag(self, tag):
        if self.tag_obj:
            tmp = self.tag_obj.get(unicode(tag))
            return tmp[0] if tmp else  ''
        else:
            return ''

    def writeTag(self, tag, val):
        self.tag_obj[unicode(tag)] = unicode(val)

def main(args):
    """
    """
    # This is nonsense, don't need to pass that argument twice
    scanner = scan.Scanner()

    if not scanner.scan_album(args.album):
        sys.stderr.write('Invalid Album!\n')
        sys.exit(1)

    # Construct an album representation
    # (This function will be moved to the lib)
    m = const.REGEX_ALBUM_FOLDER.match(args.album).groupdict()
    if not m:
        # A bit reduntant, but better safe than sorry
        sys.stderr.write("Could not read album folder\n")
        sys.exit(1)

    files = map(lambda fn: os.path.join(args.album, fn),
                sorted(filter(const.REGEX_TRACK_FILENAME.match,
                              os.listdir(args.album)
                       )
                )
    )
    show = ''
    for fn in files:
        audio = FLAC(fn)
        # Maybe create a util function for this purpose
        audio_dict = dict([(k,v[0]) for k,v in audio.items()])
        show += TPL_TRACK_SHOW.format(**audio_dict)
    head = TPL_ALBUM_SHOW.format(**audio_dict)
    show = head + TPL_SEPARATOR(len(head)-1) + show
    print show.strip('\n')

def getsubmission(tfile):
    data = open(tfile).read()
    torrent = decode(data)
    tname = torrent['info']['name']

    for file in torrent["info"]["files"]:
        name = "/".join(file["path"])
        flac_re = re.compile(".flac")
        if flac_re.search(name) != None:
            flacname=name
            log_re = re.compile(".log")
        if log_re.search(name) !=None:
            logname=name
    
    fpath = os.path.join(tname,flacname)
    lpath = os.path.join(tname,logname)

    audio = FLAC(fpath)
    print audio.keys()
    if not audio.has_key('musicbrainz_albumid'):
        print "ReleaseID tag is not set. Has this flac been tagged by picard?"
        return(-1)

    albumid = audio['musicbrainz_albumid'][0]
    print albumid

    q = ws.Query()
    try:
        inc = ws.ReleaseIncludes(artist=True, releaseEvents=True, labels=True,
                                 discs=True, tracks=True)
        release = q.getReleaseById(albumid, inc)
    except ws.WebServiceError, e:
        print 'Error:', e
        return(-1)

	def setImage(self, song):
		audio = FLAC(song.get("~filename", ""))
		if len(self.imgFiles) <= 0:
			return

		for p in self.imgFiles:
			try:
				audio.add_picture(p)
			except:
				printError()
				return False
		audio.save()
		## and now count the images
		count = "0"
		## if file has no images -> set to 0
		if (audio.pictures is None) or (len(audio.pictures) <= 0):
			pass
		else:
			count = str(len(audio.pictures))

		if not "pictures" in song:
			song["pictures"] = count

		if song["pictures"] <> count:
			song["pictures"] = count
		app.window.emit("artwork-changed", [song])
		return

class FlacStripper(MutagenStripper):
    """ Represent a Flac audio file
    """
    def _create_mfile(self):
        self.mfile = FLAC(self.filename)

    def remove_all(self):
        """ Remove the "metadata" block from the file
        """
        super(FlacStripper, self).remove_all()
        self.mfile.clear_pictures()
        self.mfile.save()
        return True

    def is_clean(self):
        """ Check if the "metadata" block is present in the file
        """
        return super(FlacStripper, self).is_clean() and not self.mfile.pictures

    def get_meta(self):
        """ Return the content of the metadata block if present
        """
        metadata = super(FlacStripper, self).get_meta()
        if self.mfile.pictures:
            metadata['picture:'] = 'yes'
        return metadata

def setSortTags(path):
    ext = os.path.splitext(path)[1].lower()
    meta = None

    try:
        if ext == '.mp3':
            meta = MP3(path)
        elif ext == '.m4a':
            meta = MP4(path)
        elif ext == '.flac':
            meta = FLAC(path)
        else:
            return
    except:
        pass

    if meta:
        tagsToProcess = ('ALBUM', 'ALBUMARTIST', 'ARTIST', 'TITLE')
        save = False
        try:
            for tag in tagsToProcess:
                processed = checkTagMakeSort(path, meta, tag)
                if (processed):
                    save = True
            if save:
                meta.save()
        except:
            pass

  def write_field(self, file, field, value, bypassdbwrite=False):
    filename, extension = os.path.splitext(file)
    if extension.upper() == '.MP3':
      # Try to open the ID3 tags
      try:
        audio = ID3(file)
      except mutagen.id3.ID3NoHeaderError:
        # Save a blank ID3 header first
        audio = ID3()
      id3field = self.MAP_ID3_FIELDS[field]
      fieldtype, unused, fieldname = id3field.partition(':')
      gentag = getattr(mutagen.id3, fieldtype)
      audio[id3field] = gentag(encoding=3, desc=u'%s' % fieldname, text=value)
      #audio['TXXX:TAG'] = TXXX(encoding=3, desc=u'TAG', text=tags)
    elif extension.upper() == '.FLAC':
      audio = FLAC(file)
      audio[self.MAP_FLAC_FIELDS[field]] = value
    audio.save(file)
    print "[LIBRARY] Field '%s' written in file %s" % (field, os.path.basename(file))

    # Update DB if needed
    if file in self.map_track_info:
      self.map_track_info[file][field] = value
      if not bypassdbwrite:
        self.save_database()

    def set_image(self, image):
        """Replaces all embedded images by the passed image"""

        with translate_errors():
            tag = FLAC(self["~filename"])

        try:
            data = image.read()
        except EnvironmentError as e:
            raise AudioFileError(e)

        pic = Picture()
        pic.data = data
        pic.type = APICType.COVER_FRONT
        pic.mime = image.mime_type
        pic.width = image.width
        pic.height = image.height
        pic.depth = image.color_depth

        tag.add_picture(pic)

        with translate_errors():
            tag.save()

        # clear vcomment tags
        super(FLACFile, self).clear_images()

        self.has_images = True

 def test_delete_multiple(self):
     # on delete we delete both
     f = FLAC(self.filename)
     f.delete()
     assert len(f.tags) == 0
     f = FLAC(self.filename)
     assert f.tags is None

def flac_read(fpath):
    audio = FLAC(fpath)
    return uni({
        'artist': audio.get('artist', [None])[0],
        'album': audio.get('album', [None])[0],
        'title': audio.get('title', [None])[0]
        })

 def test_force_shrink(self):
     self.test_force_grow()
     f = FLAC(self.NEW)
     f["faketag"] = "foo"
     f.save()
     f = FLAC(self.NEW)
     self.failUnlessEqual(f["faketag"], ["foo"])

 def test_largest_valid(self):
     f = FLAC(self.filename)
     pic = Picture()
     pic.data = b"\x00" * (2 ** 24 - 1 - 32)
     self.assertEqual(len(pic.write()), 2 ** 24 - 1)
     f.add_picture(pic)
     f.save()

def check_flac_tags(full_path, e):

    t = {} # "proper" tags

    tags = FLAC(full_path)

    unallowed = set(tags.keys()).difference(flac_allow)

    if unallowed:
        for item in unallowed:
            e.append("Unallowed tag: '" + item + "' - remove")

    # "minimal" tags
    for item in 'album', 'tracknumber', 'title', 'date':
        t[item] = tags[item][0]

    # Handle multiple artist tags in single track
    if len(tags['artist']) > 1:
        t['artist'] = ", ".join(tags['artist'])
    else:
        t['artist'] = tags['artist'][0]

    # "optional" tags
    for item in 'tracktotal', 'genre', 'albumartist', 'discnumber', 'disctotal':
        if item in tags:
            t[item] = tags[item][0]
        else:
            t[item] = None

    return t, e

	def _loadTags(self):
		try:
			audio = FLAC()
			audio.load(self.uri)
			return audio.tags
		except Exception, e:
			return None

 def tag(self):
     if self.type == 'Free Lossless Audio Codec':
         f = FLAC(self.name)
         tags = CUE_META.flac_tags(self.track_nr)
         for t in tags[0]:
             f[t] = tags[0][t]
         f.save()

def media_info(f):
    aid_re = re.compile("brainz.*album.*id",re.I)
    has_info = 0
    ext = os.path.splitext(f)[-1]
    if ext == ".mp3":
        has_info = 1
        info = ID3(f)
        format = "MP3"
    if ext == ".flac":
        has_info = 1
        info = FLAC(f)
        format = "FLAC"
    if ext == ".ogg":
        has_info = 1
        info = OggVorbis(f)
        format = "OGG"

    if not has_info:
        return {}
    for k in info.keys():
        if re.search(aid_re,k) != None:
            aid = info[k]
            if type(aid) ==mutagen.id3.TXXX:
                aid = aid.__unicode__()
            if type(aid) == type([0]):
                aid = aid[0]
    
    info_d = {}
    info_d['mbid'] = aid
    return info_d

 def write_genre(self, file_path, file_ext, genre):
     '''write genre to a single file'''
     if file_ext == '.flac':
         tag = FLAC(file_path)
     elif file_ext == '.mp3':
         tag = EasyID3(file_path)
     tag['genre'] = genre
     tag.save()

 def test_write_reread(self):
     flac = FLAC(self.NEW)
     del(flac["artist"])
     flac.save()
     flac2 = FLAC(self.NEW)
     self.failUnlessEqual(flac["title"], flac2["title"])
     data = open(self.NEW, "rb").read(1024)
     self.failIf("Tunng" in data)