from light9.ascoltami.playlist import Playlist, NoSuchSong

class App:

    def __init__(self, graph, show):

        self.graph = graph

        self.player = Player(onEOS=self.onEOS)

        self.show = show

        self.playlist = Playlist.fromShow(graph, show)

    def run(self, musicPort):

        # the cherrypy server would wedge when vidref pounds on it; this

        # one seems to run

        thread.start_new(web.httpserver.runbasic,

                         (makeWebApp(self).wsgifunc(),

                          ('0.0.0.0', musicPort)))

        mainloop = gobject.MainLoop()

        mainloop.run()

    def onEOS(self, song):

        self.player.pause()

        self.player.seek(0)

        try:

            nextSong = self.playlist.nextSong(song)

        except NoSuchSong: # we're at the end of the playlist

            return

        self.player.setSong(nextSong, play=False)

if __name__ == "__main__":

    logging.basicConfig()

    log = logging.getLogger()

    gobject.threads_init()

    parser = optparse.OptionParser()

    parser.add_option('--show',

        help='show URI, like http://light9.bigasterisk.com/show/dance2008')

    parser.add_option("-v", "--verbose", action="store_true",

                      help="logging.DEBUG")

    (options, args) = parser.parse_args()

    log.setLevel(logging.DEBUG if options.verbose else logging.INFO)

    if not options.show:

        raise ValueError("missing --show http://...")

    graph = showconfig.getGraph()

    app = App(graph, URIRef(options.show))

    musicPort = networking.musicPort()

    app.run(musicPort)

from light9.ascoltami.playlist import Playlist

playlist = Playlist.fromShow(showconfig.getGraph(), showconfig.showUri())

for p in playlist.allSongPaths():

parser.add_option("-t", type="float", default=.01,

parser.add_option("-a", "--all", action="store_true",

if options.all:

    playlist = Playlist.fromShow(showconfig.getGraph(), showconfig.showUri())

    for inpath in playlist.allSongPaths():

    inpath, outpath = args

    def __init__(self, autoStopOffset=4, onEOS=None):

        """autoStopOffset is the number of seconds before the end of

        song before automatically stopping (which is really pausing).

        onEOS is an optional function to be called when we reach the

        end of a stream (for example, can be used to advance the song).

        It is called with one argument which is the URI of the song that

        just finished."""

            if not self.onEOS:

                if self.isPlaying() and t >= self.duration() - .2:

                    # i don't expect to hit dur exactly with this

                    # polling. What would be better would be to watch for

                    # the EOS signal and react to that

                    self.onEOS(self.getSong())

    def setSong(self, songUri, play=True):

        if play:

            self.pipeline.set_state(gst.STATE_PLAYING)

            self.playStartTime = time.time()

    def getSong(self):

        """Returns the URI of the current song."""

        return self.playbin.get_property("uri")

from light9.showconfig import getSongsFromShow

from light9.namespaces import L9

class NoSuchSong(ValueError):

    """Raised when a song is requested that doesn't exist (e.g. one

    after the last song in the playlist)."""

class Playlist(object):

    def __init__(self, graph, playlistUri):

        self.songs = list(graph.items(playlistUri))

    def nextSong(self, currentSong):

        """Returns the next song in the playlist or raises NoSuchSong if 

        we are at the end of the playlist."""

        try:

            currentIndex = self.songs.index(currentSong)

        except IndexError:

            raise ValueError("%r is not in the current playlist (%r)." % \

                (currentSong, self.playlistUri))

        try:

            nextSong = self.songs[currentIndex + 1]

        except IndexError:

            raise NoSuchSong("%r is the last item in the playlist." % \

                             currentSong)

        return nextSong

    def allSongs(self):

        """Returns a list of all song URIs in order."""

        return self.songs

    def allSongPaths(self):

        """Returns a list of the filesystem paths to all songs in order."""

        paths = []

        for song in self.songs:

            p = graph.value(song, L9['showPath'])

            assert p.startswith("file://"), p

            p = p[len("file://"):]

            paths.append(p)

        return paths

    @classmethod

    def fromShow(playlistClass, graph, show):

        playlistUri = graph.value(show, L9['playList'])

        if not playlistUri:

            raise ValueError("%r has no l9:playList" % show)

        return playlistClass(graph, playlistUri)

from light9.showconfig import getSongsFromShow

app = None

        player = app.player

        graph = app.graph

        playingLocation = player.getSong()

        player = app.player

        graph = app.graph

        songs = getSongsFromShow(graph, app.show)

        graph = app.graph

        app.player.setSong(songLocation(graph, URIRef(web.data())))

        player = app.player

def makeWebApp(theApp):

    global app

    app = theApp

    urls = (r"/", "root",

            r"/time", "timeResource",

            r"/song", "songResource",

            r"/songs", "songs",

            r"/seekPlayOrPause", "seekPlayOrPause",

    return web.application(urls, globals(), autoreload=False)

def showUri():

    """Return the show URI associated with $LIGHT9_SHOW."""

    return URIRef(file(path.join(root(), 'URI').read().strip()))

def getSongsFromShow(graph, show):

    playList = graph.value(show, L9['playList'])

    if not playList:

        raise ValueError("%r has no l9:playList" % show)

    songs = list(graph.items(playList))

    return songs