def __skip_test_english_human_titlecase_sentences(s):
"""Checks trickier human title casing, also assuming it's enabled"""
s.assertEquals(u"Buffy the Vampire Slayer: The Album",
title(u"Buffy the vampire slayer: the album"))
s.assertEquals(u"Killing Is My Business... and Business Is Good!",
title(u"Killing is my business... And business is good!"))
s.assertEquals(u"Herbie Hancock - The Definitive",
title(u"herbie hancock - the definitive"))
def test_unicode(s):
s.assertEquals(u"Fooäbar",
title(u"fooäbar"))
s.assertEquals(u"Los Años Felices",
title(u"los años felices"))
s.assertEquals(u"Ñandú",
title(u"ñandú"))
s.assertEquals(u"Österreich",
title(u"österreich"))
def _people(self, song, box):
vb = Gtk.VBox()
if "artist" in song:
if len(song.list("artist")) == 1:
title = _("artist")
else:
title = _("artists")
title = util.capitalize(title)
l = Label(song["artist"])
l.set_ellipsize(Pango.EllipsizeMode.END)
vb.pack_start(l, False, True, 0)
else:
title = tag("~people")
for names, tag_ in [
("performers", "performer"), ("lyricists", "lyricist"),
("arrangers", "arranger"), ("composers", "composer"),
("conductors", "conductor"), ("authors", "author")
]:
if tag_ in song:
l = Label(song[tag_])
l.set_ellipsize(Pango.EllipsizeMode.END)
if len(song.list(tag_)) == 1:
name = tag(tag_)
else:
name = _(names)
vb.pack_start(Frame(util.capitalize(name), l), False, False, 0)
performers = {}
for tag_ in song:
if "performer:" in tag_:
for person in song[tag_].split('\n'):
try:
performers[str(person)]
except:
performers[str(person)] = []
performers[str(person)].append(
util.title(tag_[tag_.find(":") + 1:]))
if len(performers) > 0:
performerstr = ''
for performer in performers:
performerstr += performer + ' ('
i = 0
for part in performers[performer]:
if i != 0:
performerstr += ', '
performerstr += part
i += 1
performerstr += ')\n'
l = Label(performerstr)
l.set_ellipsize(Pango.EllipsizeMode.END)
if len(performers) == 1:
name = tag("performer")
else:
name = _("performers")
vb.pack_start(Frame(util.capitalize(name), l), False, False, 0)
if not vb.get_children():
vb.destroy()
else:
box.pack_start(Frame(title, vb), False, False, 0)
def test_quotes(s):
s.assertEquals(u"Hello Goodbye (A Song)",
title(u"hello goodbye (a song)"))
s.assertEquals(u"Hello Goodbye 'A Song'",
title(u"hello goodbye 'a song'"))
s.assertEquals(u'Hello Goodbye "A Song"',
title(u'hello goodbye "a song"'))
s.assertEquals(u"Hello Goodbye „A Song”",
title(u"hello goodbye „a song”"))
s.assertEquals(u"Hello Goodbye ‘A Song’",
title(u"hello goodbye ‘a song’"))
s.assertEquals(u"Hello Goodbye “A Song”",
title(u"hello goodbye “a song”"))
s.assertEquals(u"Hello Goodbye »A Song«",
title(u"hello goodbye »a song«"))
s.assertEquals(u"Hello Goodbye «A Song»",
title(u"hello goodbye «a song»"))
s.assertEquals(u"\"24\" Theme", title(u"\"24\" theme"))
s.assertEquals(u"\"Mad-Dog\" Mike", title(u"\"mad-dog\" mike"))
def _people(self, song, box):
vb = Gtk.VBox()
if "artist" in song:
if len(song.list("artist")) == 1:
title = _("artist")
else:
title = _("artists")
title = util.capitalize(title)
l = Label(song["artist"])
l.set_ellipsize(Pango.EllipsizeMode.END)
vb.pack_start(l, False, True, 0)
else:
title = tag("~people")
for tag_ in ["performer", "lyricist", "arranger", "composer",
"conductor", "author"]:
if tag_ in song:
l = Label(song[tag_])
l.set_ellipsize(Pango.EllipsizeMode.END)
if len(song.list(tag_)) == 1:
name = tag(tag_)
else:
name = readable(tag_, plural=True)
vb.pack_start(Frame(util.capitalize(name), l), False, False, 0)
performers = {}
for tag_ in song:
if "performer:" in tag_:
for person in song[tag_].split('\n'):
try:
performers[str(person)]
except:
performers[str(person)] = []
performers[str(person)].append(
util.title(tag_[tag_.find(":") + 1:]))
if len(performers) > 0:
performerstr = ''
for performer in performers:
performerstr += performer + ' ('
i = 0
for part in performers[performer]:
if i != 0:
performerstr += ', '
performerstr += part
i += 1
performerstr += ')\n'
l = Label(performerstr)
l.set_ellipsize(Pango.EllipsizeMode.END)
if len(performers) == 1:
name = tag("performer")
else:
name = _("performers")
vb.pack_start(Frame(util.capitalize(name), l), False, False, 0)
if not vb.get_children():
vb.destroy()
else:
box.pack_start(Frame(title, vb), False, False, 0)
def _roles(self, tag):
"""Returns a defaultdict of name => [role, ...]."""
roles = collections.defaultdict(list)
for key in self.keys():
if key.startswith(tag + ":"):
role = util.title(key[1 + len(tag):])
for name in self.list(key):
roles[name].append(role)
for name in self.list(tag):
roles[name]
return roles
def test_quotes(s):
s.assertEquals(u"Hello Goodbye (A Song)",
title(u"hello goodbye (a song)"))
s.assertEquals(u"Hello Goodbye 'A Song'",
title(u"hello goodbye 'a song'"))
s.assertEquals(u'Hello Goodbye "A Song"',
title(u'hello goodbye "a song"'))
s.assertEquals(u"Hello Goodbye „A Song”",
title(u"hello goodbye „a song”"))
s.assertEquals(u"Hello Goodbye ‘A Song’",
title(u"hello goodbye ‘a song’"))
s.assertEquals(u"Hello Goodbye “A Song”",
title(u"hello goodbye “a song”"))
s.assertEquals(u"Hello Goodbye »A Song«",
title(u"hello goodbye »a song«"))
s.assertEquals(u"Hello Goodbye «A Song»",
title(u"hello goodbye «a song»"))
s.assertEquals(u"\"24\" Theme",
title(u"\"24\" theme"))
s.assertEquals(u"\"Mad-Dog\" Mike",
title(u"\"mad-dog\" mike"))
def desc_cdf(column, cell, model, iter, data):
row = model[iter]
if row:
name = re.sub(':[a-z]+$', '', row[0].strip('~#'))
try:
t = _TAGS[name]
valid = (not t.hidden
and t.numeric == row[0].startswith('~#'))
val = t.desc if valid else name
except KeyError:
val = name
cell.set_property('text', util.title(val.replace('~', ' / ')))
def desc_cdf(column, cell, model, iter, data):
row = model[iter]
if row:
name = re.sub(':[a-z]+$', '', row[0].strip('~#'))
try:
t = _TAGS[name]
valid = (not t.hidden
and t.numeric == row[0].startswith('~#'))
val = t.desc if valid else name
except KeyError:
val = name
cell.set_property('text', util.title(val.replace('~', ' / ')))
def __skip_test_english_human_titlecase(s):
"""Checks human title casing, assuming that it defaults to enabled"""
s.assertEquals(u"System of a Down",
title(u"System Of A Down"))
s.assertEquals(u"The Man with the Golden Gun",
title(u"The Man With The Golden gun"))
s.assertEquals(u"Live and Let Die",
title(u"Live And Let Die"))
# s.assertEquals(u"The Vitamins are in my Fresh California Raisins",
# Updated to match modifications to is/are/am rules:
s.assertEquals(u"The Vitamins Are in My Fresh California Raisins",
title(u"the vitamins are in my fresh california raisins"))
s.assertEquals(u"Dig In",
title(u"dig in"))
s.assertEquals(u"In da Club",
title(u"in da club"))
# See Issue 616
s.assertEquals(u" Dodgy Are the Spaces ",
title(u" dodgy are the spaces "))
s.assertEquals(u"Space: The Final Frontier",
title(u"Space: the final frontier"))
def _people(self, song, box):
data = []
if "artist" in song:
title = (_("artist")
if len(song.list("artist")) == 1 else _("artists"))
title = util.capitalize(title)
data.append((title, song["artist"]))
for tag_ in [
"performer", "lyricist", "arranger", "composer", "conductor",
"author"
]:
if tag_ in song:
name = (tag(tag_) if len(song.list(tag_)) == 1 else readable(
tag_, plural=True))
data.append((name, song[tag_]))
performers = defaultdict(list)
for tag_ in song:
if "performer:" in tag_:
for person in song.list(tag_):
role = util.title(tag_.split(':', 1)[1])
performers[role].append(person)
if performers:
text = '\n'.join("%s (%s)" % (', '.join(names), part)
for part, names in performers.iteritems())
name = (tag("performer")
if len(performers) == 1 else _("performers"))
data.append((name, text))
table = Table(len(data))
for i, (key, text) in enumerate(data):
key = util.capitalize(util.escape(key) + ":")
table.attach(Label(markup=key),
0,
1,
i,
i + 1,
xoptions=Gtk.AttachOptions.FILL)
label = Label(text, ellipsize=True)
table.attach(label, 1, 2, i, i + 1)
box.pack_start(Frame(tag("~people"), table), False, False, 0)
def _people(self, song, box):
data = []
if "artist" in song:
title = (_("artist") if len(song.list("artist")) == 1
else _("artists"))
title = util.capitalize(title)
data.append((title, song["artist"]))
for tag_ in ["performer", "lyricist", "arranger", "composer",
"conductor", "author"]:
if tag_ in song:
name = (tag(tag_) if len(song.list(tag_)) == 1
else readable(tag_, plural=True))
data.append((name, song[tag_]))
performers = defaultdict(list)
for tag_ in song:
if "performer:" in tag_:
for person in song.list(tag_):
role = util.title(tag_.split(':', 1)[1])
performers[role].append(person)
if performers:
text = '\n'.join("%s (%s)" % (', '.join(names), part)
for part, names in performers.iteritems())
name = (tag("performer") if len(performers) == 1
else _("performers"))
data.append((name, text))
table = Table(len(data))
for i, (key, text) in enumerate(data):
key = util.capitalize(util.escape(key) + ":")
table.attach(Label(markup=key), 0, 1, i, i + 1,
xoptions=Gtk.AttachOptions.FILL)
label = Label(text, ellipsize=True)
table.attach(label, 1, 2, i, i + 1)
box.pack_start(Frame(tag("~people"), table), False, False, 0)
def test_oneword(self):
self.failUnlessEqual(title("foobar"), "Foobar")
def filter(self, tag, value):
return util.title(value)
def test_apostrophe(self):
self.failUnlessEqual(title("it's"), "It's")
def test_nonalphabet(self):
self.failUnlessEqual(title("foo 1bar"), "Foo 1bar")
def test_twowords(self):
self.failUnlessEqual(title("foo bar"), "Foo Bar")
def test_empty(self):
self.failUnlessEqual(title(""), "")
def __call__(self, key, default=u"", connector=" - "):
"""Return a key, synthesizing it if necessary. A default value
may be given (like dict.get); the default default is an empty
unicode string (even if the tag is numeric).
If a tied tag ('a~b') is requested, the 'connector' keyword
argument may be used to specify what it is tied with.
For details on tied tags, see the documentation for util.tagsplit."""
if key[:1] == "~":
key = key[1:]
if "~" in key:
# FIXME: decode ~filename etc.
if not isinstance(default, basestring): return default
return connector.join(
filter(None,
map(lambda x: isinstance(x, basestring) and x or str(x),
map(lambda x: (isinstance(x, float) and "%.2f" % x) or x,
map(self.__call__, util.tagsplit("~" + key)))))) or default
elif key == "#track":
try: return int(self["tracknumber"].split("/")[0])
except (ValueError, TypeError, KeyError): return default
elif key == "#disc":
try: return int(self["discnumber"].split("/")[0])
except (ValueError, TypeError, KeyError): return default
elif key == "length":
length = self.get("~#length")
if length is None: return default
else: return util.format_time(length)
elif key == "#rating":
return dict.get(self, "~" + key, const.DEFAULT_RATING)
elif key == "rating":
return util.format_rating(self("~#rating"))
elif key == "people":
join = "\n".join
people = filter(None, map(self.__call__, PEOPLE))
if not people: return default
people = join(people).split("\n")
index = people.index
return join([person for (i, person) in enumerate(people)
if index(person) == i])
elif key == "peoplesort":
join = "\n".join
people = filter(None, map(self.__call__, PEOPLE_SORT))
people = join(people).split("\n")
index = people.index
return (join([person for (i, person) in enumerate(people)
if index(person) == i]) or
self("~people", default, connector))
elif key == "performers" or key == "performer":
performers = {}
for key in self.keys():
if key.startswith("performer:"):
role = key.split(":", 1)[1]
for value in self.list(key):
try:
performers[str(value)]
except:
performers[str(value)] = []
performers[str(value)].append(util.title(role))
values = []
if len(performers) > 0:
for performer in performers:
roles = ''
i = 0
for role in performers[performer]:
if i > 0:
roles += ', '
roles += role
i += 1
values.append("%s (%s)" % (performer, roles))
values.extend(self.list("performer"))
if not values: return default
return "\n".join(values)
elif key == "performerssort" or key == "performersort":
values = []
for key in self.keys():
if key.startswith("performersort:"):
role = key.split(":", 1)[1]
for value in self.list(key):
values.append("%s (%s)" % (value, role))
values.extend(self.list("performersort"))
return ("\n".join(values) or
self("~performers", default, connector))
elif key == "basename":
return os.path.basename(self["~filename"]) or self["~filename"]
elif key == "dirname":
return os.path.dirname(self["~filename"]) or self["~filename"]
elif key == "uri":
try: return self["~uri"]
except KeyError:
return URI.frompath(self["~filename"])
elif key == "format":
return self.get("~format", self.format)
elif key == "year":
return self.get("date", default)[:4]
elif key == "#year":
try: return int(self.get("date", default)[:4])
except (ValueError, TypeError, KeyError): return default
elif key == "originalyear":
return self.get("originaldate", default)[:4]
elif key == "#originalyear":
try: return int(self.get("originaldate", default)[:4])
except (ValueError, TypeError, KeyError): return default
elif key == "#tracks":
try: return int(self["tracknumber"].split("/")[1])
except (ValueError, IndexError, TypeError, KeyError):
return default
elif key == "#discs":
try: return int(self["discnumber"].split("/")[1])
except (ValueError, IndexError, TypeError, KeyError):
return default
elif key == "lyrics":
try: fileobj = file(self.lyric_filename, "rU")
except EnvironmentError: return default
else: return fileobj.read().decode("utf-8", "replace")
elif key == "playlists":
# See Issue 876
# Avoid circular references from formats/__init__.py
from quodlibet.util.collection import Playlist
try:
start = time.time()
playlists = Playlist.playlists_featuring(self)
import random
if not random.randint(0, 1000):
print_d("A sample song('~playlists') call: took %d μs "
% (1E6 * (time.time() - start)))
return "\n".join([s.name for s in playlists])
except KeyError:
return default
elif key.startswith("#replaygain_"):
try:
val = self.get(key[1:], default)
return round(float(val.split(" ")[0]), 2)
except (ValueError, TypeError, AttributeError): return default
elif key[:1] == "#":
key = "~" + key
if key in self: self[key]
elif key in INTERN_NUM_DEFAULT:
return dict.get(self, key, 0)
else:
try: val = self[key[2:]]
except KeyError: return default
try: return int(val)
except ValueError:
try: return float(val)
except ValueError: return default
else: return dict.get(self, "~" + key, default)
elif key == "title":
title = dict.get(self, "title")
if title is None:
basename = self("~basename")
basename = basename.decode(const.FSCODING, "replace")
return "%s [%s]" % (basename, _("Unknown"))
else: return title
elif key in SORT_TO_TAG:
try: return self[key]
except KeyError:
key = SORT_TO_TAG[key]
return dict.get(self, key, default)
def test_extra_spaces(s):
s.assertEquals(u" Space", title(u" space"))
s.assertEquals(u" Dodgy Spaces ", title(u" dodgy spaces "))
def test_quirks(s):
# This character is not an apostrophe, it's a single quote!
s.assertEquals(u"Mama’S Boy", title(u"mama’s boy"))
# This is actually an accent character, not an apostrophe either.
s.assertEquals(u"Mama`S Boy", title(u"mama`s boy"))
def test_apostrophe(self):
self.failUnlessEqual(title("it's"), "It's")
def test_two_words_and_one_not(self):
self.failUnlessEqual(title("foo 1 bar"), "Foo 1 Bar")
def test_nonalphabet(self):
self.failUnlessEqual(title("foo 1bar"), "Foo 1bar")
def test_preserve(self):
self.failUnlessEqual(title("fooBar"), "FooBar")
def test_twowords(self):
self.failUnlessEqual(title("foo bar"), "Foo Bar")
def test_extra_spaces(s):
s.assertEquals(u" Space", title(u" space"))
s.assertEquals(u" Dodgy Spaces ", title(u" dodgy spaces "))
def test_quirks(s):
# This character is not an apostrophe, it's a single quote!
s.assertEquals(u"Mama’S Boy", title(u"mama’s boy"))
# This is actually an accent character, not an apostrophe either.
s.assertEquals(u"Mama`S Boy", title(u"mama`s boy"))
def __skip_test_tricky_apostrophes(s):
s.assertEquals(u"Guns 'n' Roses", title(u"Guns 'n' roses"))
s.assertEquals(u"Scarlett O'Hara", title(u"scarlett o'hara"))
s.assertEquals(u"Scarlett O'Hara", title(u"Scarlett O'hara"))
s.assertEquals(u"No Life 'til Leather", title(u"no life 'til leather"))
def test_unicode(s):
s.assertEquals(u"Fooäbar", title(u"fooäbar"))
s.assertEquals(u"Los Años Felices", title(u"los años felices"))
s.assertEquals(u"Ñandú", title(u"ñandú"))
s.assertEquals(u"Österreich", title(u"österreich"))
def process_tag(self, value):
if not self.allow_all_caps:
value = value.lower()
value = util.title(value)
return _humanise(value) if self.human else value
def test_oneword(self):
self.failUnlessEqual(title("foobar"), "Foobar")
def test_basics(s):
s.assertEquals(u"Mama's Boy", title(u"mama's boy"))
s.assertEquals(u"The A-Sides", title(u"the a-sides"))
s.assertEquals(u"Hello Goodbye", title(u"hello goodbye"))
s.assertEquals(u"HELLO GOODBYE", title(u"HELLO GOODBYE"))
s.assertEquals(u"", title(u""))
def test_preserve(self):
self.failUnlessEqual(title("fooBar"), "FooBar")
def process_tag(self, value):
if not self.allow_all_caps:
value = value.lower()
value = util.title(value)
return _humanise(value) if self.human else value
def test_two_words_and_one_not(self):
self.failUnlessEqual(title("foo 1 bar"), "Foo 1 Bar")
def title(self, value):
"""Mimic the plugin's basic operation without config etc"""
value = util.title(value)
return humanise(value)
def filter(self, tag, value): return util.title(value) class SplitTag(FilterCheckButton):
def filter(self, tag, value):
return util.title(value)
def test_basics(s):
s.assertEquals(u"Mama's Boy", title(u"mama's boy"))
s.assertEquals(u"The A-Sides", title(u"the a-sides"))
s.assertEquals(u"Hello Goodbye", title(u"hello goodbye"))
s.assertEquals(u"HELLO GOODBYE", title(u"HELLO GOODBYE"))
s.assertEquals(u"", title(u""))
def test_empty(self):
self.failUnlessEqual(title(""), "")
