Python util.title函数代码示例

 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 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 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 __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 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
#.........这里部分代码省略.........

 def test_two_words_and_one_not(self):
     self.failUnlessEqual(title("foo 1  bar"), "Foo 1  Bar")

 def test_apostrophe(self):
     self.failUnlessEqual(title("it's"), "It's")

 def test_preserve(self):
     self.failUnlessEqual(title("fooBar"), "FooBar")

 def test_nonalphabet(self):
     self.failUnlessEqual(title("foo 1bar"), "Foo 1bar")

 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_twowords(self):
     self.failUnlessEqual(title("foo bar"), "Foo Bar")