How to use the mediafile.Image function in mediafile

def test_image_encoding(self):
        """For compatibility with OS X/iTunes.

        See https://github.com/beetbox/beets/issues/899#issuecomment-62437773
        """

        for v23 in [True, False]:
            mf = self._make_test(id3v23=v23)
            try:
                mf.images = [
                    mediafile.Image(b'data', desc=u""),
                    mediafile.Image(b'data', desc=u"foo"),
                    mediafile.Image(b'data', desc=u"\u0185"),
                ]
                mf.save()
                apic_frames = mf.mgfile.tags.getall('APIC')
                encodings = dict([(f.desc, f.encoding) for f in apic_frames])
                self.assertEqual(encodings, {
                    u"": mutagen.id3.Encoding.LATIN1,
                    u"foo": mutagen.id3.Encoding.LATIN1,
                    u"\u0185": mutagen.id3.Encoding.UTF16,
                })
            finally:
                self._delete_test()

def test_image_encoding(self):
        """For compatibility with OS X/iTunes.

        See https://github.com/beetbox/beets/issues/899#issuecomment-62437773
        """

        for v23 in [True, False]:
            mf = self._make_test(id3v23=v23)
            try:
                mf.images = [
                    mediafile.Image(b'data', desc=u""),
                    mediafile.Image(b'data', desc=u"foo"),
                    mediafile.Image(b'data', desc=u"\u0185"),
                ]
                mf.save()
                apic_frames = mf.mgfile.tags.getall('APIC')
                encodings = dict([(f.desc, f.encoding) for f in apic_frames])
                self.assertEqual(encodings, {
                    u"": mutagen.id3.Encoding.LATIN1,
                    u"foo": mutagen.id3.Encoding.LATIN1,
                    u"\u0185": mutagen.id3.Encoding.UTF16,
                })
            finally:
                self._delete_test()

def test_set_image_structure(self):
        mediafile = self._mediafile_fixture('empty')
        image = Image(data=self.png_data, desc=u'album cover',
                      type=ImageType.front)
        mediafile.images = [image]
        mediafile.save()

        mediafile = MediaFile(mediafile.path)
        self.assertEqual(len(mediafile.images), 1)

        image = mediafile.images[0]
        self.assertEqual(image.data, self.png_data)
        self.assertEqual(image.mime_type, 'image/png')
        self.assertExtendedImageAttributes(image, desc=u'album cover',
                                           type=ImageType.front)

def test_add_image_structure(self):
        mediafile = self._mediafile_fixture('image')
        self.assertEqual(len(mediafile.images), 2)

        image = Image(data=self.png_data, desc=u'the composer',
                      type=ImageType.composer)
        mediafile.images += [image]
        mediafile.save()

        mediafile = MediaFile(mediafile.path)
        self.assertEqual(len(mediafile.images), 3)

        images = (i for i in mediafile.images if i.desc == u'the composer')
        image = next(images, None)
        self.assertExtendedImageAttributes(
            image, desc=u'the composer', type=ImageType.composer
        )

def test_add_tiff_image_fails(self):
        mediafile = self._mediafile_fixture('empty')
        with self.assertRaises(ValueError):
            mediafile.images = [Image(data=self.tiff_data)]

def fetch(self, mutagen_file):
        images = []
        for cover_type, cover_tag in self.TAG_NAMES.items():
            try:
                frame = mutagen_file[cover_tag]
                text_delimiter_index = frame.value.find(b'\x00')
                if text_delimiter_index > 0:
                    comment = frame.value[0:text_delimiter_index]
                    comment = comment.decode('utf-8', 'replace')
                else:
                    comment = None
                image_data = frame.value[text_delimiter_index + 1:]
                images.append(Image(data=image_data, type=cover_type,
                                    desc=comment))
            except KeyError:
                pass

        return images

def deserialize(self, flac_picture):
        return Image(data=flac_picture.data, desc=flac_picture.desc,
                     type=flac_picture.type)

def fetch(self, mutagen_file):
        images = []
        if 'metadata_block_picture' not in mutagen_file:
            # Try legacy COVERART tags.
            if 'coverart' in mutagen_file:
                for data in mutagen_file['coverart']:
                    images.append(Image(base64.b64decode(data)))
            return images
        for data in mutagen_file["metadata_block_picture"]:
            try:
                pic = mutagen.flac.Picture(base64.b64decode(data))
            except (TypeError, AttributeError):
                continue
            images.append(Image(data=pic.data, desc=pic.desc,
                                type=pic.type))
        return images

def deserialize(self, asf_picture):
        mime, data, type, desc = _unpack_asf_image(asf_picture.value)
        return Image(data, desc=desc, type=type)

def __set__(self, mediafile, data):
        if data:
            mediafile.images = [Image(data=data)]
        else:
            mediafile.images = []