454 lines
12 KiB
Python
454 lines
12 KiB
Python
from __future__ import annotations
|
|
|
|
from lrx_cli.lrc import LRCData
|
|
from lrx_cli.models import CacheStatus
|
|
|
|
|
|
def _reformat(text: str) -> str:
|
|
return str(LRCData(text))
|
|
|
|
|
|
def test_time_tag_formats_are_normalized() -> None:
|
|
raw = "\n".join(
|
|
[
|
|
"[00:01]a",
|
|
"[00:02.3]b",
|
|
"[00:03.45]c",
|
|
"[00:04.678]d",
|
|
"[00:05:999]e",
|
|
]
|
|
)
|
|
|
|
normalized = _reformat(raw)
|
|
|
|
assert normalized == "\n".join(
|
|
[
|
|
"[00:01.00]a",
|
|
"[00:02.30]b",
|
|
"[00:03.45]c",
|
|
"[00:04.68]d",
|
|
"[00:05.99]e",
|
|
]
|
|
)
|
|
|
|
|
|
def test_non_timed_lines_are_kept_as_lyrics() -> None:
|
|
raw = " plain line \n\n other line "
|
|
|
|
normalized = _reformat(raw)
|
|
|
|
assert normalized == "plain line\n\nother line"
|
|
|
|
|
|
def test_word_sync_tags_are_parsed_and_export_controlled() -> None:
|
|
raw = "[00:01.00]<00:01>he <00:01.50>llo\n[00:02.00]plain"
|
|
|
|
data = LRCData(raw)
|
|
|
|
assert data.to_text(include_word_sync=False) == "[00:01.00]he llo\n[00:02.00]plain"
|
|
assert (
|
|
data.to_text(include_word_sync=True)
|
|
== "[00:01.00]<00:01.00>he <00:01.50>llo\n[00:02.00]plain"
|
|
)
|
|
|
|
|
|
def test_midline_line_tags_are_kept_as_plain_text() -> None:
|
|
raw = "[00:01.00]Lyric [00:02.00]line"
|
|
|
|
normalized = _reformat(raw)
|
|
|
|
assert normalized == "[00:01.00]Lyric [00:02.00]line"
|
|
|
|
|
|
def test_space_between_line_tag_and_lyric_is_consumed() -> None:
|
|
raw = "[00:01.2] hello"
|
|
|
|
normalized = _reformat(raw)
|
|
|
|
assert normalized == "[00:01.20]hello"
|
|
|
|
|
|
def test_consecutive_line_sync_tags_with_spaces_are_parsed_as_one_line() -> None:
|
|
raw = "[00:01] [00:02.3] chorus"
|
|
|
|
data = LRCData(raw)
|
|
assert len(data.lines) == 1
|
|
assert str(data) == "[00:01.00][00:02.30]chorus"
|
|
assert data.to_plain() == "chorus\nchorus"
|
|
|
|
|
|
def test_non_leading_time_like_text_is_plain_lyric() -> None:
|
|
raw = "intro [00:01]line"
|
|
|
|
normalized = _reformat(raw)
|
|
|
|
assert normalized == "intro [00:01]line"
|
|
|
|
|
|
def test_is_synced_and_detect_sync_status_follow_non_zero_rule() -> None:
|
|
plain_text = "just some lyrics\nwithout tags"
|
|
unsynced_text = "[00:00.00]a\n[00:00.00]b"
|
|
synced_text = "[00:00.00]a\n[00:01.00]b"
|
|
|
|
assert LRCData(plain_text).is_synced() is False
|
|
assert LRCData(plain_text).detect_sync_status() is CacheStatus.SUCCESS_UNSYNCED
|
|
|
|
assert LRCData(unsynced_text).is_synced() is False
|
|
assert LRCData(unsynced_text).detect_sync_status() is CacheStatus.SUCCESS_UNSYNCED
|
|
|
|
assert LRCData(synced_text).is_synced() is True
|
|
assert LRCData(synced_text).detect_sync_status() is CacheStatus.SUCCESS_SYNCED
|
|
|
|
|
|
def test_normalize_unsynced_covers_documented_blank_and_tag_rules() -> None:
|
|
lyrics = "\n[00:12.34]first\nsecond\n\n[00:00.00]third"
|
|
|
|
normalized = str(LRCData(lyrics).normalize_unsynced())
|
|
|
|
assert normalized == "\n".join(
|
|
[
|
|
"[00:00.00]first",
|
|
"[00:00.00]second",
|
|
"[00:00.00]",
|
|
"[00:00.00]third",
|
|
]
|
|
)
|
|
|
|
|
|
def test_normalize_unsynced_preserves_doc_tags_and_middle_blanks() -> None:
|
|
text = "\n".join(["[ar:Artist]", "", "[00:03.00]line", "[ti:Song]", "", " tail "])
|
|
|
|
normalized = LRCData(text).normalize_unsynced()
|
|
|
|
assert normalized.tags == {"ar": "Artist", "ti": "Song"}
|
|
assert str(normalized) == "\n".join(
|
|
[
|
|
"[ar:Artist]",
|
|
"[00:00.00]line",
|
|
"[ti:Song]",
|
|
"[00:00.00]",
|
|
"[00:00.00]tail",
|
|
]
|
|
)
|
|
|
|
|
|
def test_normalize_unsynced_strips_word_sync_markup_from_lyric_text() -> None:
|
|
text = "[00:02.00]<00:01.00>he <00:01.50>llo"
|
|
|
|
normalized = str(LRCData(text).normalize_unsynced())
|
|
|
|
assert normalized == "[00:00.00]he llo"
|
|
|
|
|
|
def test_normalize_unsynced_result_is_always_unsynced() -> None:
|
|
text = "[00:05.00]a\n[00:10.00]b"
|
|
|
|
normalized = LRCData(text).normalize_unsynced()
|
|
|
|
assert normalized.is_synced() is False
|
|
assert normalized.detect_sync_status() is CacheStatus.SUCCESS_UNSYNCED
|
|
|
|
|
|
def test_normalize_moves_doc_tags_to_top_and_removes_offset_tag() -> None:
|
|
text = "\n".join(
|
|
[
|
|
"[00:02.00]b",
|
|
"[ar:Artist]",
|
|
"[offset:500]",
|
|
"[00:01.00]a",
|
|
"[ti:Song]",
|
|
]
|
|
)
|
|
|
|
normalized = LRCData(text).to_normalized_text()
|
|
|
|
assert normalized == "\n".join(
|
|
[
|
|
"[ar:Artist]",
|
|
"[ti:Song]",
|
|
"[00:01.50]a",
|
|
"[00:02.50]b",
|
|
]
|
|
)
|
|
|
|
|
|
def test_normalize_expands_multi_time_tags_and_sorts_lyrics() -> None:
|
|
text = "\n".join(
|
|
[
|
|
"[00:03.00]c",
|
|
"[00:02.00][00:01.00]x",
|
|
]
|
|
)
|
|
|
|
normalized = LRCData(text).to_normalized_text()
|
|
|
|
assert normalized == "\n".join(["[00:01.00]x", "[00:02.00]x", "[00:03.00]c"])
|
|
|
|
|
|
def test_normalize_preserves_input_order_for_equal_timestamps() -> None:
|
|
text = "\n".join(
|
|
[
|
|
"[00:00.00]first",
|
|
"[00:00.00]second",
|
|
"[00:00.00]third",
|
|
"[00:01.00]later",
|
|
]
|
|
)
|
|
|
|
normalized = LRCData(text).to_normalized_text()
|
|
|
|
assert normalized == "\n".join(
|
|
["[00:00.00]first", "[00:00.00]second", "[00:00.00]third", "[00:01.00]later"]
|
|
)
|
|
|
|
|
|
def test_normalize_converts_unsynced_lines_and_removes_word_sync_tags() -> None:
|
|
text = "\n".join(
|
|
[
|
|
"plain",
|
|
"<00:01.00>he <00:01.50>llo",
|
|
"[00:02.00]<00:02.20>world",
|
|
"",
|
|
]
|
|
)
|
|
|
|
normalized = LRCData(text).to_normalized_text()
|
|
|
|
assert normalized == "\n".join(
|
|
[
|
|
"[00:00.00]plain",
|
|
"[00:00.00]he llo",
|
|
"[00:02.00]world",
|
|
]
|
|
)
|
|
|
|
|
|
def test_to_normalized_text_is_separate_from_plain() -> None:
|
|
data = LRCData("[offset:500]\n[00:02.00]b\n[00:01.00]a")
|
|
|
|
assert data.to_plain() == "a\nb"
|
|
assert data.to_normalized_text() == "[00:01.50]a\n[00:02.50]b"
|
|
|
|
|
|
def test_to_text_default_forces_unsynced_tagging() -> None:
|
|
data = LRCData("line\nother")
|
|
|
|
assert data.to_text() == "[00:00.00]line\n[00:00.00]other"
|
|
|
|
|
|
def test_str_is_raw_serializer_while_to_text_converts_unsynced() -> None:
|
|
data = LRCData("line\nother")
|
|
|
|
assert str(data) == "line\nother"
|
|
assert data.to_text() == "[00:00.00]line\n[00:00.00]other"
|
|
|
|
|
|
def test_to_plain_duplicates_lines_for_multi_line_times() -> None:
|
|
text = "\n".join(
|
|
[
|
|
"[00:02.00][00:01.00]hello",
|
|
"[00:03.00]world",
|
|
"no-tag-line",
|
|
"[00:00.00]zero-only",
|
|
]
|
|
)
|
|
|
|
plain = LRCData(text).to_plain()
|
|
|
|
# In synced mode, lines with standard tags are kept (including [00:00.00]),
|
|
# lines without leading standard tags are ignored, and output is sorted by tag timestamp.
|
|
assert plain == "\n".join(["zero-only", "hello", "hello", "world"])
|
|
|
|
|
|
def test_to_plain_sorts_lines_by_timestamp_across_lines() -> None:
|
|
text = "\n".join(
|
|
[
|
|
"[00:05.00]late",
|
|
"[00:01.00]early",
|
|
"[00:03.00]middle",
|
|
]
|
|
)
|
|
|
|
plain = LRCData(text).to_plain()
|
|
|
|
assert plain == "\n".join(["early", "middle", "late"])
|
|
|
|
|
|
def test_to_plain_preserves_input_order_for_equal_timestamps() -> None:
|
|
text = "\n".join(
|
|
[
|
|
"[00:00.00]first",
|
|
"[00:00.00]second",
|
|
"[00:00.00]third",
|
|
"[00:01.00]later",
|
|
]
|
|
)
|
|
|
|
plain = LRCData(text).to_plain()
|
|
|
|
assert plain == "\n".join(["first", "second", "third", "later"])
|
|
|
|
|
|
def test_to_plain_deduplicate_collapses_only_consecutive_equals() -> None:
|
|
text = "\n".join(
|
|
[
|
|
"[00:01.00][00:02.00]hello",
|
|
"[00:03.00]hello",
|
|
"[00:04.00]",
|
|
"[00:05.00]",
|
|
"[00:06.00]world",
|
|
"[00:07.00]hello",
|
|
]
|
|
)
|
|
|
|
plain = LRCData(text).to_plain(deduplicate=True)
|
|
|
|
assert plain == "\n".join(["hello", "", "world", "hello"])
|
|
|
|
|
|
def test_to_plain_excludes_doc_tags_and_untagged_lines_in_unsynced_mode() -> None:
|
|
text = "\n".join(["[ar:Artist]", "[00:00.00]only-zero", "plain line"])
|
|
|
|
plain = LRCData(text).to_plain()
|
|
|
|
assert plain == "only-zero\nplain line"
|
|
|
|
|
|
def test_to_plain_outer_blanks_stripped_and_untagged_lines_excluded_in_synced_mode() -> (
|
|
None
|
|
):
|
|
text = "\n\n[00:01.00]line1\n\n[00:01.00]\n[00:02.00]line2\nline3\n \n"
|
|
|
|
plain = LRCData(text).to_plain()
|
|
|
|
assert plain == "line1\n\nline2"
|
|
|
|
|
|
def test_reformat_pipeline_trims_outer_blanks_and_preserves_inner_blanks() -> None:
|
|
text = "\n\n[00:01]a\n\n[00:02]b\n\n"
|
|
|
|
normalized = str(LRCData(text))
|
|
|
|
assert normalized == "[00:01.00]a\n\n[00:02.00]b"
|
|
|
|
|
|
def test_single_doc_tag_line_is_preserved_and_registered() -> None:
|
|
data = LRCData("[ar:Artist]\n[00:01.00]line")
|
|
|
|
assert data.tags == {"ar": "Artist"}
|
|
assert len(data.lines) == 2
|
|
assert str(data) == "[ar:Artist]\n[00:01.00]line"
|
|
assert data.to_plain() == "line"
|
|
|
|
|
|
def test_multiple_doc_tags_on_one_line_are_plain_lyrics() -> None:
|
|
data = LRCData("[ar:Artist][ti:Song]")
|
|
|
|
assert data.tags == {}
|
|
assert len(data.lines) == 1
|
|
assert data.lines[0].text == "[ar:Artist][ti:Song]"
|
|
|
|
|
|
def test_doc_tag_after_lyrics_is_still_recognized_as_doc_tag() -> None:
|
|
data = LRCData("[00:01.00]line\n[ar:Artist]")
|
|
|
|
assert data.tags == {"ar": "Artist"}
|
|
assert len(data.lines) == 2
|
|
assert str(data) == "[00:01.00]line\n[ar:Artist]"
|
|
assert data.to_plain() == "line"
|
|
|
|
|
|
def test_unknown_lines_before_lyrics_are_preserved_and_do_not_start_lyrics() -> None:
|
|
data = LRCData("comment line\n[ar:Artist]\n[00:01.00]line")
|
|
|
|
assert data.tags == {"ar": "Artist"}
|
|
assert len(data.lines) == 3
|
|
assert str(data) == "comment line\n[ar:Artist]\n[00:01.00]line"
|
|
assert data.to_plain() == "line"
|
|
|
|
|
|
def test_to_plain_excludes_doc_tags_but_keeps_lyrics() -> None:
|
|
data = LRCData("[ar:Artist]\n[00:01.00]line\n[ti:Song]\nplain")
|
|
|
|
assert data.to_plain() == "line"
|
|
|
|
|
|
def test_non_space_between_line_tags_stops_tag_parsing() -> None:
|
|
data = LRCData("[00:01.00]x[00:02.00]tail")
|
|
|
|
assert len(data.lines) == 1
|
|
assert str(data) == "[00:01.00]x[00:02.00]tail"
|
|
assert data.to_plain() == "x[00:02.00]tail"
|
|
|
|
|
|
def test_line_only_time_tag_is_valid_empty_lyric() -> None:
|
|
data = LRCData("[00:01.00]")
|
|
|
|
assert len(data.lines) == 1
|
|
assert str(data) == "[00:01.00]"
|
|
assert data.to_plain() == ""
|
|
|
|
|
|
def test_word_sync_markup_only_changes_output_when_enabled() -> None:
|
|
a = LRCData("[00:01.00]<00:00.50>lyric")
|
|
b = LRCData("[00:01.00]lyric")
|
|
|
|
assert a.to_text(include_word_sync=False) == "[00:01.00]lyric"
|
|
assert b.to_text(include_word_sync=False) == "[00:01.00]lyric"
|
|
assert a.to_text(include_word_sync=True) == "[00:01.00]<00:00.50>lyric"
|
|
assert b.to_text(include_word_sync=True) == "[00:01.00]lyric"
|
|
|
|
|
|
def test_str_preserves_word_sync_markup() -> None:
|
|
data = LRCData("[00:01.00]<00:00.50>lyric")
|
|
|
|
assert str(data) == "[00:01.00]<00:00.50>lyric"
|
|
|
|
|
|
def test_str_preserves_offset_tag_and_does_not_apply_it() -> None:
|
|
data = LRCData("[offset:500]\n[00:01.00]a")
|
|
|
|
assert str(data) == "[offset:500]\n[00:01.00]a"
|
|
assert data.to_normalized_text() == "[00:01.50]a"
|
|
|
|
|
|
def test_str_preserves_doc_tag_order_and_duplicates_exactly() -> None:
|
|
data = LRCData("[ar:First]\n[ti:Song]\n[ar:Second]\n[00:01.00]line")
|
|
|
|
assert str(data) == "[ar:First]\n[ti:Song]\n[ar:Second]\n[00:01.00]line"
|
|
|
|
|
|
def test_str_does_not_expand_or_sort_multi_time_lines() -> None:
|
|
data = LRCData("[00:03.00]c\n[00:02.00][00:01.00]x")
|
|
|
|
assert str(data) == "[00:03.00]c\n[00:02.00][00:01.00]x"
|
|
assert data.to_normalized_text() == "[00:01.00]x\n[00:02.00]x\n[00:03.00]c"
|
|
|
|
|
|
def test_str_preserves_plain_text_lines_without_injecting_time_tags() -> None:
|
|
data = LRCData("plain line\n[ar:Artist]\nother line")
|
|
|
|
assert str(data) == "plain line\n[ar:Artist]\nother line"
|
|
assert data.to_text() == "[00:00.00]plain line\n[ar:Artist]\n[00:00.00]other line"
|
|
|
|
|
|
def test_word_sync_line_with_empty_tail_keeps_word_tag_only_when_enabled() -> None:
|
|
data = LRCData("[00:01.00]<00:02.00>")
|
|
|
|
assert data.to_text(include_word_sync=False) == "[00:01.00]"
|
|
assert data.to_text(include_word_sync=True) == "[00:01.00]<00:02.00>"
|
|
|
|
|
|
def test_to_plain_for_doc_only_text_is_empty() -> None:
|
|
data = LRCData("[ar:Artist]\n[ti:Song]")
|
|
|
|
assert data.to_plain() == ""
|
|
|
|
|
|
def test_duplicate_doc_tag_key_last_value_wins_but_lines_are_kept() -> None:
|
|
data = LRCData("[ar:First]\n[ar:Second]\n[00:01.00]line")
|
|
|
|
assert data.tags == {"ar": "Second"}
|
|
assert len(data.lines) == 3
|
|
assert str(data).startswith("[ar:First]\n[ar:Second]\n")
|