11640011262

Committed 02 Nov 2024 04:48AM UTC coverage: 90.89% (+0.07%) from 90.821%

Build # 11640011262

Build Type

push

github

Committed by

snejus

Commit Message

title: recover wrongly split titles

Run Details

584 of 648 branches covered (90.12%)

Branch coverage included in aggregate %.

3 of 7 new or added lines in 1 file covered. (42.86%)

47 existing lines in 5 files now uncovered.

1122 of 1229 relevant lines covered (91.29%)

13.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.24

/beetsplug/bandcamp/album_name.py

"""Module with album parsing logic."""

import re
from dataclasses import dataclass
from functools import cached_property
from typing import Any, Dict, List, Match, Optional

from .helpers import PATTERNS, Helpers

JSONDict = Dict[str, Any]


@dataclass
class AlbumName:
    _series = r"(?i:\b(part|volume|pt|vol)\b\.?)"
    SERIES = re.compile(rf"{_series}[ ]?[A-Z\d.-]+\b")
    SERIES_FMT = re.compile(rf"^(.+){_series} *0*")
    REMIX_IN_TITLE = re.compile(r"[\( :]+(with re|inc|\+).*mix(\)|(.*$))", re.I)
    CLEAN_EPLP = re.compile(r"(?:[([]|Double ){0,2}(\b[EL]P\b)\S?", re.I)
    EPLP_ALBUM = re.compile(r"\b(?!VA|0\d|-)([^\s:]+\b|[&, ])+ [EL]P\b( [\w#][^ ]+$)?")
    EPLP_ALBUM_LINE = re.compile(r"\b(?=[A-Z])(((?!Vinyl|VA|-)[^:\s]+ )+)[EL]P$", re.M)
    QUOTED_ALBUM = re.compile(r"\B(['\"])([^'\"]+)\1\B( VA\d+| [EL]P)?", re.I)
    ALBUM_IN_DESC = re.compile(r"(?:Title: ?|Album(?::|/Single) )([^\n]+)")
    CLEAN_VA_EXCLUDE = re.compile(r"\w various artists \w", re.I)
    CLEAN_VA = re.compile(
        r"""
          (?<=^)v[./]?a\b(?!\ \w)[^A-z(]*
        | \W*Various\ Artists?\b(?!\ [A-z])[^A-z(]*
    """,
        re.IGNORECASE + re.VERBOSE,
    )
    COMPILATION_IN_TITLE = re.compile(r"compilation|best of|anniversary", re.I)

    original: str
    description: str
    from_track_titles: Optional[str]

    remove_artists = True

    @cached_property
    def from_description(self) -> Optional[str]:
        """Try finding album name in the release description."""
        if m := self.ALBUM_IN_DESC.search(self.description):
            self.remove_artists = False
            return m.group(1).strip()

        return None

    @cached_property
    def mentions_compilation(self) -> bool:
        return bool(self.COMPILATION_IN_TITLE.search(self.original))

    @cached_property
    def from_title(self) -> Optional[str]:
        """Try to guess album name from the original title.

        Return the first match from below, defaulting to None:
        1. If 'EP' or 'LP' is in the original name, album name is what precedes it.
        2. If quotes are used in the title, they probably contain the album name.
        """
        if m := self.QUOTED_ALBUM.search(self.original):
            return m.expand(r"\2\3")

        if m := self.EPLP_ALBUM.search(self.original):
            return m.group()

        return None

    @cached_property
    def album_names(self) -> List[str]:
        priority_list = [
            self.from_track_titles,
            self.from_description,
            self.from_title,
            self.original,
        ]
        return list(filter(None, priority_list))

    @cached_property
    def name(self) -> str:
        return next(iter(self.album_names))

    @cached_property
    def series_part(self) -> Optional[str]:
        """Return series if it is found in any of the album names."""
        for name in self.album_names:
            if m := self.SERIES.search(name):
                return m.group()

        return None

    @staticmethod
    def format_series(m: Match[str]) -> str:
        """Format the series part in an album.

        * Ensure 'Vol' or 'Pt' is suffixed by '.'
        * Ensure that it is followed by a space
        * Leading zeroes from the number are already removed by 'SERIES_FMT'.
        """
        album, series = m.groups()
        if album[0].isupper() and not series[0].isupper():
            series = series.capitalize()

        suffix = "." if len(series) in {2, 3} else ""
        return f"{album}{series}{suffix} "

    def standardize_series(self, album: str) -> str:
        """Standardize 'Vol', 'Part' etc. format."""
        series = self.series_part
        if not series:
            return album

        if series.lower() not in album.lower():
            # series was not given in the description, but found in the original name
            if series[0].isalpha():
                series = f", {series}"

            album += series
        else:
            # move from the beginning to the end of the album
            album, moved = re.subn(rf"^({series})\W+(.+)", r"\2, \1", album)
            if not moved:
                # otherwise, ensure that it is delimited by a comma
                album = re.sub(rf"(?<=\w)( {series}(?!\)))", r",\1", album)

        return self.SERIES_FMT.sub(self.format_series, album)

    @staticmethod
    def remove_label(name: str, label: str) -> str:
        if not label:
            return name

        pattern = re.compile(
            rf"""
            \W*               # pick up any punctuation
            (?<!\w[ ])        # cannot be preceded by a simple word
            \b{re.escape(label)}\b
            (?!.[A-Za-z])     # cannot be followed by a word
            ([^[\]\w]|\d)*    # pick up any digits and punctuation
        """,
            flags=re.VERBOSE | re.IGNORECASE,
        )
        return pattern.sub(" ", name).strip()

    @classmethod
    def remove_va(cls, name: str) -> str:
        if not cls.CLEAN_VA_EXCLUDE.search(name):
            return cls.CLEAN_VA.sub(" ", name)

        return name

    @classmethod
    def clean(cls, name: str, to_clean: List[str], label: str = "") -> str:
        """Return clean album name.

        Catalogue number and artists to be removed are provided as 'to_clean'.
        """
        allowed_chars = r"[*|,. \u2013\u2020]"
        for word in map(re.escape, filter(None, to_clean)):
            name = re.sub(
                rf"""
    (
        (?P<br>[([])                # match either an opening bracket/parens
      | (^|{allowed_chars})+        # or line start with and all allowed chars
    )
    (?<!\ [x&]\ )                   # do not remove A2 from 'A1 x A2' or 'A1 & A2'
    (?<!\ of\ )                     # do not remove Artist from 'Best of Artist'
    (((compiled\ |selected\ )?by|vs)\ )?  # remove these prefixes when they are present
    (?i:{word})                     # match the word we want to remove
    (?!
        ['.\d]                      # cannot be followed by these characters
      | [ ](deluxe|&|[el]p\b|x\b)   # cannot be followed by ' deluxe', ' &' ' ep', ' x'
    )
    (?(br)                          # if we had a bracket/parens match
        [])]                        # then match closing bracket/parens
      | ({allowed_chars}|-|\d+$)*   # otherwise remove any of these patterns
    )
                """,
                " ",
                name,
                flags=re.VERBOSE | re.IGNORECASE | re.UNICODE,
            ).strip("_: ")

        name = PATTERNS["ft"].sub("", name)
        name = cls.remove_va(name)
        name = Helpers.clean_name(name)
        name = cls.remove_label(name, label)
        name = cls.REMIX_IN_TITLE.sub(" ", name).strip("- ")

        # uppercase EP and LP, and remove surrounding parens / brackets
        name = cls.CLEAN_EPLP.sub(lambda x: x.group(1).upper(), name)
        return name.strip(" /")

    def check_eplp(self, album: str) -> str:
        """Return album name followed by 'EP' or 'LP' if that's given in the comments.

        When album is given, search for the album.
        Otherwise, search for (Capital-case Album Name) (EP or LP) and return the match.
        """
        if album:
            m = re.search(rf"{re.escape(album)} [EL]P\b", self.description)
        else:
            m = self.EPLP_ALBUM_LINE.search(self.description)

        if m:
            return m.group()

        return album

    def get(
        self,
        catalognum: str,
        original_artists: List[str],
        artists: List[str],
        label: str,
    ) -> str:
        original_album = self.name
        if artists and original_album.lower() == artists[0].lower():
            # if album is named by the main artist, keep it as it is
            return original_album
        to_clean = [catalognum]
        if self.remove_artists:
            to_clean.extend(original_artists + artists)
        to_clean = sorted(filter(None, set(to_clean)), key=len, reverse=True)

        album = self.clean(original_album, to_clean, label)
        if album.startswith("("):
            album = original_album

        album = self.check_eplp(self.standardize_series(album))

        if "split ep" in album.lower() or (not album and len(artists) == 2):
            album = " / ".join(artists)

        return album or catalognum or original_album

1	"""Module with album parsing logic."""
2
3	import re	15✔
4	from dataclasses import dataclass	15✔
5	from functools import cached_property	15✔
6	from typing import Any, Dict, List, Match, Optional	15✔
7
8	from .helpers import PATTERNS, Helpers	15✔
9
10	JSONDict = Dict[str, Any]	15✔
11
12
13	@dataclass	15✔
14	class AlbumName:	15✔
15	_series = r"(?i:\b(part\|volume\|pt\|vol)\b\.?)"	15✔
16	SERIES = re.compile(rf"{_series}[ ]?[A-Z\d.-]+\b")	15✔
17	SERIES_FMT = re.compile(rf"^(.+){_series} 0")	15✔
18	REMIX_IN_TITLE = re.compile(r"[\( :]+(with re\|inc\|\+).mix(\)\|(.$))", re.I)	15✔
19	CLEAN_EPLP = re.compile(r"(?:[([]\|Double ){0,2}(\b[EL]P\b)\S?", re.I)	15✔
20	EPLP_ALBUM = re.compile(r"\b(?!VA\|0\d\|-)([^\s:]+\b\|[&, ])+ [EL]P\b( [\w#][^ ]+$)?")	15✔
21	EPLP_ALBUM_LINE = re.compile(r"\b(?=[A-Z])(((?!Vinyl\|VA\|-)[^:\s]+ )+)[EL]P$", re.M)	15✔
22	QUOTED_ALBUM = re.compile(r"\B(['\"])([^'\"]+)\1\B( VA\d+\| [EL]P)?", re.I)	15✔
23	ALBUM_IN_DESC = re.compile(r"(?:Title: ?\|Album(?::\|/Single) )([^\n]+)")	15✔
24	CLEAN_VA_EXCLUDE = re.compile(r"\w various artists \w", re.I)	15✔
25	CLEAN_VA = re.compile(	15✔
26	r"""
27	(?<=^)v[./]?a\b(?!\ \w)[^A-z(]*
28	\| \WVarious\ Artists?\b(?!\ [A-z])[^A-z(]
29	""",
30	re.IGNORECASE + re.VERBOSE,
31	)
32	COMPILATION_IN_TITLE = re.compile(r"compilation\|best of\|anniversary", re.I)	15✔
33
34	original: str	15✔
35	description: str	15✔
36	from_track_titles: Optional[str]	15✔
37
38	remove_artists = True	15✔
39
40	@cached_property	15✔
41	def from_description(self) -> Optional[str]:	15✔
42	"""Try finding album name in the release description."""
43	if m := self.ALBUM_IN_DESC.search(self.description):	15✔
44	self.remove_artists = False	15✔
45	return m.group(1).strip()	15✔
46
47	return None	15✔
48
49	@cached_property	15✔
50	def mentions_compilation(self) -> bool:	15✔
51	return bool(self.COMPILATION_IN_TITLE.search(self.original))	15✔
52
53	@cached_property	15✔
54	def from_title(self) -> Optional[str]:	15✔
55	"""Try to guess album name from the original title.
56
57	Return the first match from below, defaulting to None:
58	1. If 'EP' or 'LP' is in the original name, album name is what precedes it.
59	2. If quotes are used in the title, they probably contain the album name.
60	"""
61	if m := self.QUOTED_ALBUM.search(self.original):	15✔
62	return m.expand(r"\2\3")	15✔
63
64	if m := self.EPLP_ALBUM.search(self.original):	15✔
65	return m.group()	15✔
66
67	return None	15✔
68
69	@cached_property	15✔
70	def album_names(self) -> List[str]:	15✔
71	priority_list = [	15✔
72	self.from_track_titles,
73	self.from_description,
74	self.from_title,
75	self.original,
76	]
77	return list(filter(None, priority_list))	15✔
78
79	@cached_property	15✔
80	def name(self) -> str:	15✔
81	return next(iter(self.album_names))	15✔
82
83	@cached_property	15✔
84	def series_part(self) -> Optional[str]:	15✔
85	"""Return series if it is found in any of the album names."""
86	for name in self.album_names:	15✔
87	if m := self.SERIES.search(name):	15!
UNCOV 88	return m.group()	×
89
90	return None	15✔
91
92	@staticmethod	15✔
93	def format_series(m: Match[str]) -> str:	15✔
94	"""Format the series part in an album.
95
96	* Ensure 'Vol' or 'Pt' is suffixed by '.'
97	* Ensure that it is followed by a space
98	* Leading zeroes from the number are already removed by 'SERIES_FMT'.
99	"""
UNCOV 100	album, series = m.groups()	×
UNCOV 101	if album[0].isupper() and not series[0].isupper():	×
UNCOV 102	series = series.capitalize()	×
103
UNCOV 104	suffix = "." if len(series) in {2, 3} else ""	×
UNCOV 105	return f"{album}{series}{suffix} "	×
106
107	def standardize_series(self, album: str) -> str:	15✔
108	"""Standardize 'Vol', 'Part' etc. format."""
109	series = self.series_part	15✔
110	if not series:	15!
111	return album	15✔
112
UNCOV 113	if series.lower() not in album.lower():	×
114	# series was not given in the description, but found in the original name
UNCOV 115	if series[0].isalpha():	×
UNCOV 116	series = f", {series}"	×
117
UNCOV 118	album += series	×
119	else:
120	# move from the beginning to the end of the album
UNCOV 121	album, moved = re.subn(rf"^({series})\W+(.+)", r"\2, \1", album)	×
122	if not moved:	×
123	# otherwise, ensure that it is delimited by a comma
UNCOV 124	album = re.sub(rf"(?<=\w)( {series}(?!\)))", r",\1", album)	×
125
UNCOV 126	return self.SERIES_FMT.sub(self.format_series, album)	×
127
128	@staticmethod	15✔
129	def remove_label(name: str, label: str) -> str:	15✔
130	if not label:	15✔
131	return name	15✔
132
133	pattern = re.compile(	15✔
134	rf"""
135	\W* # pick up any punctuation
136	(?<!\w[ ]) # cannot be preceded by a simple word
137	\b{re.escape(label)}\b
138	(?!.[A-Za-z]) # cannot be followed by a word
139	([^[\]\w]\|\d)* # pick up any digits and punctuation
140	""",
141	flags=re.VERBOSE \| re.IGNORECASE,
142	)
143	return pattern.sub(" ", name).strip()	15✔
144
145	@classmethod	15✔
146	def remove_va(cls, name: str) -> str:	15✔
147	if not cls.CLEAN_VA_EXCLUDE.search(name):	15✔
148	return cls.CLEAN_VA.sub(" ", name)	15✔
149
150	return name	15✔
151
152	@classmethod	15✔
153	def clean(cls, name: str, to_clean: List[str], label: str = "") -> str:	15✔
154	"""Return clean album name.
155
156	Catalogue number and artists to be removed are provided as 'to_clean'.
157	"""
158	allowed_chars = r"[*\|,. \u2013\u2020]"	15✔
159	for word in map(re.escape, filter(None, to_clean)):	15✔
160	name = re.sub(	15✔
161	rf"""
162	(
163	(?P<br>[([]) # match either an opening bracket/parens
164	\| (^\|{allowed_chars})+ # or line start with and all allowed chars
165	)
166	(?<!\ [x&]\ ) # do not remove A2 from 'A1 x A2' or 'A1 & A2'
167	(?<!\ of\ ) # do not remove Artist from 'Best of Artist'
168	(((compiled\ \|selected\ )?by\|vs)\ )? # remove these prefixes when they are present
169	(?i:{word}) # match the word we want to remove
170	(?!
171	['.\d] # cannot be followed by these characters
172	\| [ ](deluxe\|&\|[el]p\b\|x\b) # cannot be followed by ' deluxe', ' &' ' ep', ' x'
173	)
174	(?(br) # if we had a bracket/parens match
175	[])] # then match closing bracket/parens
176	\| ({allowed_chars}\|-\|\d+$)* # otherwise remove any of these patterns
177	)
178	""",
179	" ",
180	name,
181	flags=re.VERBOSE \| re.IGNORECASE \| re.UNICODE,
182	).strip("_: ")
183
184	name = PATTERNS["ft"].sub("", name)	15✔
185	name = cls.remove_va(name)	15✔
186	name = Helpers.clean_name(name)	15✔
187	name = cls.remove_label(name, label)	15✔
188	name = cls.REMIX_IN_TITLE.sub(" ", name).strip("- ")	15✔
189
190	# uppercase EP and LP, and remove surrounding parens / brackets
191	name = cls.CLEAN_EPLP.sub(lambda x: x.group(1).upper(), name)	15✔
192	return name.strip(" /")	15✔
193
194	def check_eplp(self, album: str) -> str:	15✔
195	"""Return album name followed by 'EP' or 'LP' if that's given in the comments.
196
197	When album is given, search for the album.
198	Otherwise, search for (Capital-case Album Name) (EP or LP) and return the match.
199	"""
200	if album:	15✔
201	m = re.search(rf"{re.escape(album)} [EL]P\b", self.description)	15✔
202	else:
203	m = self.EPLP_ALBUM_LINE.search(self.description)	15✔
204
205	if m:	15✔
206	return m.group()	15✔
207
208	return album	15✔
209
210	def get(	15✔
211	self,
212	catalognum: str,
213	original_artists: List[str],
214	artists: List[str],
215	label: str,
216	) -> str:
217	original_album = self.name	15✔
218	if artists and original_album.lower() == artists[0].lower():	15!
219	# if album is named by the main artist, keep it as it is
UNCOV 220	return original_album	×
221	to_clean = [catalognum]	15✔
222	if self.remove_artists:	15✔
223	to_clean.extend(original_artists + artists)	15✔
224	to_clean = sorted(filter(None, set(to_clean)), key=len, reverse=True)	15✔
225
226	album = self.clean(original_album, to_clean, label)	15✔
227	if album.startswith("("):	15!
UNCOV 228	album = original_album	×
229
230	album = self.check_eplp(self.standardize_series(album))	15✔
231
232	if "split ep" in album.lower() or (not album and len(artists) == 2):	15!
UNCOV 233	album = " / ".join(artists)	×
234
235	return album or catalognum or original_album	15✔

snejus / beetcamp / 11640011262

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous