gistfile1.py

#!/usr/bin/python


class Artist:

    def __init__(self, name, long_name):

        self.discography = []
        self.name = name
        self.long_name = long_name
        self.padding = 0

    def add_album(self, album):

        self.discography.append(album)

    def get_album_size(self):

        return max([len(i.songs) for i in self.discography])

    def get_discography_size(self):

        return len(self.discography)

    def set_padding(self, albums, songs):

        self.padding = (2 + songs) * (albums - len(self.discography))

        for cd in self.discography:
            cd.set_padding(songs)

    def __unicode__(self):

        temp = [self.name, self.long_name]
        temp.extend([unicode(i) for i in self.discography])
        temp.extend([u''] * self.padding)

        return u'\t'.join(temp)


class Album:

    def __init__(self, name, year, songs):

        self.name = name
        self.year = year
        self.songs = songs
        self.padding = 0

    def set_padding(self, songs):

        self.padding = songs - len(self.songs)

    def __unicode__(self):

        temp = [self.name, self.year]
        temp.extend(self.songs)
        temp.extend([u''] * self.padding)

        return u'\t'.join(temp)


class Parser:

    def __init__(self):

        self.artists = {}

    def feed_line(self, line):

        if len(line) == 0:
            return

        tokens = line.strip().split('\t')
        index = u'\t'.join(tokens[0:2])

        if index not in self.artists:
            self.artists[index] = Artist(tokens[0], tokens[1])

        album = Album(tokens[2], tokens[3], tokens[4:])
        self.artists[index].add_album(album)

    def __get_list_size(self):

        asize = [i.get_album_size() for i in self.artists.values()]
        dsize = [i.get_discography_size() for i in self.artists.values()]

        return max(dsize), max(asize)

    def __generate_header(self, albums, songs):

        temp = [u'Artist', u'']

        for cd in range(albums):
            temp.append(u'Album%d' % (cd + 1))
            temp.append(u'Year%d' % (cd + 1))
            song = u'Song%d-' % (cd + 1)
            temp.extend([song + unicode(i + 1) for i in range(songs)])

        return u'\t'.join(temp)

    def __generate_content(self, albums, songs):

        temp = []

        for artist in self.artists.values():
            artist.set_padding(albums, songs)
            temp.append(unicode(artist))

        return temp

    def __unicode__(self):

        albums, songs = self.__get_list_size()
        header = self.__generate_header(albums, songs)
        content = self.__generate_content(albums, songs)

        return u'\r\n'.join([header] + content + [u''])


if __name__ == '__main__':

    import sys
    import codecs

    if len(sys.argv) != 3:
        print 'usage: temp.py <inputfile> <outputfile>'
        sys.exit(1)

    infile = sys.argv[1]
    outfile = sys.argv[2]
    parser = Parser()

    with codecs.open(infile, 'r', 'utf-16') as f:
        content = f.read()
        for line in content.split('\r\n'):
            parser.feed_line(line)

    with codecs.open(outfile, 'w', 'utf-16') as f:
        f.write(unicode(parser))