Esempio n. 1
0
def test_pathlib_compatibility():
    try:
        import pathlib
    except ImportError:
        return
    testfile = next(iter(testfiles.keys()))
    filename = pathlib.Path(testfolder) / testfile
    TinyTag.get(filename)
Esempio n. 2
0
def test_binary_path_compatibility():
    binary_file_path = os.path.join(
        os.path.dirname(__file__).encode('utf-8'), b'\x01.mp3')
    testfile = os.path.join(testfolder, next(iter(testfiles.keys())))
    shutil.copy(testfile, binary_file_path)
    assert os.path.exists(binary_file_path)
    TinyTag.get(binary_file_path)
    os.unlink(binary_file_path)
    assert not os.path.exists(binary_file_path)
Esempio n. 3
0
def test_mp3_utf_8_invalid_string_can_be_ignored():
    tag = TinyTag.get(os.path.join(testfolder,
                                   'samples/utf-8-id3v2-invalid-string.mp3'),
                      ignore_errors=True)
    # the title used to be Gran dia, but I replaced the first byte with 0xFF,
    # which should be ignored here
    assert tag.title == 'ran día'
Esempio n. 4
0
def test_file_reading(testfile, expected):
    filename = os.path.join(testfolder, testfile)
    tag = TinyTag.get(filename)

    for key, expected_val in expected.items():
        if key.startswith('__'):
            continue
        result = getattr(tag, key)
        fmt_string = 'field "%s": got %s (%s) expected %s (%s)!'
        fmt_values = (key, repr(result), type(result), repr(expected_val),
                      type(expected_val))
        if key == 'duration' and result is not None and expected_val is not None:
            # allow duration to be off by 100 ms and a maximum of 1%
            if abs(result - expected_val) < 0.100:
                if expected_val and min(result, expected_val) / max(
                        result, expected_val) > 0.99:
                    continue
        assert result == expected_val, fmt_string % fmt_values
    # for custom samples, allow not specifying all values
    if expected.get('_do_not_require_all_values'):
        return
    undefined_in_fixture = {}
    for key, val in tag.__dict__.items():
        if key.startswith('_') or val is None:
            continue
        if key not in expected:
            undefined_in_fixture[key] = val
    assert not undefined_in_fixture, 'Missing data in fixture \n%s' % str(
        undefined_in_fixture)
Esempio n. 5
0
def drive_index(folder: Path):
    for item in folder.rglob('*'):
        if item.is_file():
            try:
                track = TinyTag.get(item)
                yield get_track_metadata(item, track)
            except TinyTagException:
                pass
Esempio n. 6
0
def test_mp3_image_loading2():
    tag = TinyTag.get(os.path.join(testfolder, 'samples/12oz.mp3'), image=True)
    image_data = tag.get_image()
    assert image_data is not None
    assert 2000 < len(image_data) < 2500, (
        'Image is %d bytes but should be around 145kb' % len(image_data))
    assert image_data.startswith(b'\xff\xd8\xff\xe0'), (
        'The image data must start with a jpeg '
        'header')
Esempio n. 7
0
def test_flac_image_loading():
    tag = TinyTag.get(os.path.join(testfolder, 'samples/flac_with_image.flac'),
                      image=True)
    image_data = tag.get_image()
    assert image_data is not None
    assert 70000 < len(image_data) < 80000, (
        'Image is %d bytes but should be around 75kb' % len(image_data))
    assert image_data.startswith(b'\xff\xd8\xff\xe0'), (
        'The image data must start with a jpeg '
        'header')
Esempio n. 8
0
def test_mp3_image_loading_with_utf8_description():
    tag = TinyTag.get(os.path.join(testfolder,
                                   'samples/image-text-encoding.mp3'),
                      image=True)
    image_data = tag.get_image()
    assert image_data is not None
    assert 5700 < len(image_data) < 6000, (
        'Image is %d bytes but should be around 6kb' % len(image_data))
    assert image_data.startswith(b'\xff\xd8\xff\xe0'), (
        'The image data must start with a jpeg '
        'header')
Esempio n. 9
0
def test_to_str():
    tag = TinyTag.get(os.path.join(testfolder, 'samples/id3v22-test.mp3'))
    assert str(tag)  # since the dict is not ordered we cannot == 'somestring'
    assert repr(tag)  # since the dict is not ordered we cannot == 'somestring'
    assert str(tag) == (
        '{"album": "Hymns for the Exiled", "albumartist": null, "artist": "Anais Mitchell", '
        '"audio_offset": 2225, "bitrate": 160.0, "channels": 2, "comment": "Waterbug Records, '
        'www.anaismitchell.com", "composer": null, "disc": null, "disc_total": null, '
        '"duration": 0.13836297152858082, "extra": {}, "filesize": 5120, "genre": null, '
        '"samplerate": 44100, "title": "cosmic american", "track": "3", "track_total": "11", '
        '"year": "2004"}')
    def extract_music(self):
        """
        Create a tuple that contains the songs' filename and their info
        :param str music_folder: path of the directory where the music is
        :return resp: The response from cmus from the issued command
        :rtype: tuple
        """

        def song_fullpath(music_folder,filename):
            """
            Extracts the fullpath of a song
            """
            return ('{}{}'.format(music_folder,filename))

        songs = []
        try:
            generator = (f for f in os.listdir(self.music_folder) if os.path.isfile(os.path.join(self.music_folder, f)))
        except (FileNotFoundError, Exception) as err:
            print('Impossible to obtain the songs: {}'.format(err))
        else:
            for song in generator:
                path = song_fullpath(self.music_folder, song)
                try:
                    new_song = TinyTag.get(path, image=True)
                except Exception:
                    try:
                        print('ok')
                        new_song = TinyTag.get(path)
                    except Exception as e: 
                        print('File {} has not a valid format for a song: {}'.format(path, e))
                        new_song = None
                finally:
                    if new_song and (new_song.bitrate and new_song.samplerate and new_song.duration):
                        # Avoid no-song files to be added
                        if (new_song.title is None) or (new_song.title == ''):
                            new_song.title = song
                        songs.append((path, new_song))
        return tuple(songs)
Esempio n. 11
0
def test_mp3_utf_8_invalid_string_raises_exception():
    with raises(TinyTagException):
        TinyTag.get(
            os.path.join(testfolder, 'samples/utf-8-id3v2-invalid-string.mp3'))
Esempio n. 12
0
def test_unpad():
    # make sure that unpad only removes trailing 0-bytes
    assert TinyTag._unpad('foo\x00') == 'foo'
    assert TinyTag._unpad('foo\x00bar\x00') == 'foobar'
Esempio n. 13
0
def test_show_hint_for_wrong_usage():
    with pytest.raises(Exception) as exc_info:
        TinyTag('filename.mp3', 0)
    assert exc_info.type == Exception
    assert exc_info.value.args[
        0] == 'Use `TinyTag.get(filepath)` instead of `TinyTag(filepath)`'
Esempio n. 14
0
def test_unsubclassed_tinytag_duration():
    tag = TinyTag(None, 0)
    tag._determine_duration(None)
Esempio n. 15
0
def test_override_encoding():
    chinese_id3 = os.path.join(testfolder, 'samples/chinese_id3.mp3')
    tag = TinyTag.get(chinese_id3, encoding='gbk')
    assert tag.artist == '苏云'
    assert tag.album == '角落之歌'
Esempio n. 16
0
def test_unsupported_extension():
    bogus_file = os.path.join(testfolder, 'samples/there_is_no_such_ext.bogus')
    TinyTag.get(bogus_file)
Esempio n. 17
0
def test_detect_magic_headers(testfile, expected):
    filename = os.path.join(testfolder, testfile)
    with io.open(filename, 'rb') as fh:
        parser = TinyTag.get_parser_class(filename, fh)
    assert parser == expected
Esempio n. 18
0
def test_unsubclassed_tinytag_parse_tag():
    tag = TinyTag(None, 0)
    tag._parse_tag(None)
Esempio n. 19
0
def test_mp3_length_estimation():
    ID3.set_estimation_precision(0.7)
    tag = TinyTag.get(os.path.join(testfolder, 'samples/silence-44-s-v1.mp3'))
    assert 3.5 < tag.duration < 4.0
Esempio n. 20
0
    formatting = (pop_param('--format', None) or pop_param('-f', None)) or 'json'
    skip_unsupported = pop_switch('--skip-unsupported', False) or pop_switch('-s', False)
    filenames = sys.argv[1:]
except Exception as exc:
    print(exc)
    usage()
    sys.exit(1)

header_printed = False

for i, filename in enumerate(filenames):
    try:
        if skip_unsupported:
            if os.path.isdir(filename):
                continue
            if not TinyTag.is_supported(filename):
                continue
        tag = TinyTag.get(filename, image=save_image_path is not None)
        if save_image_path:
            # allow for saving the image of multiple files
            actual_save_image_path = save_image_path
            if len(filenames) > 1:
                actual_save_image_path, ext = splitext(actual_save_image_path)
                actual_save_image_path += '%05d' % i + ext
            image = tag.get_image()
            if image:
                with open(actual_save_image_path, 'wb') as fh:
                    fh.write(image)
        data = {'filename': filename}
        data.update(tag.as_dict())
        if formatting == 'json':