deluge/plugins/SimpleRSS/plugin.py

class plugin_SimpleRSS:
    def __init__(self, path, deluge_core, deluge_interface):
        #set up system thingies
        import gtk, gtk.glade, os, ConfigParser, feedparser
        import deluge.common, deluge.dgtk, deluge.pref
        from time import asctime
        self.path = path
        self.core = deluge_core
        self.interface = deluge_interface
        #set up feeds file
        self.feeds_config = ConfigParser.ConfigParser()
        self.feeds_file = deluge.common.CONFIG_DIR + "/feeds.conf"
        if not os.path.isfile(self.feeds_file):
            f = open(self.feeds_file, mode='w')
            f.flush()
            f.close()
        self.feeds_config.read(self.feeds_file)
        #set up filters file
        self.filters_config = ConfigParser.ConfigParser()
        self.filters_file = deluge.common.CONFIG_DIR + "/filters.conf"
        if not os.path.isfile(self.filters_file):
            f = open(self.filters_file, mode='w')
            f.flush()
            f.close()
        self.filters_config.read(self.filters_file)
        #set up the preferences dialog
        glade = gtk.glade.XML(path + "/rss.glade")
        self.dlg = glade.get_widget("dialog")
        self.dlg.set_position(gtk.WIN_POS_CENTER)
        self.dlg.set_icon_from_file(self.path + "/rss.png")
        #set up the feeds list viewer
        self.feeds_view = glade.get_widget("feeds_view")
        model = gtk.ListStore(str, str, str)
        self.feeds_view.set_model(model)
        deluge.dgtk.add_text_column(self.feeds_view, _("Name"), 0)
        deluge.dgtk.add_text_column(self.feeds_view, _("URL"), 1)
        deluge.dgtk.add_text_column(self.feeds_view, _("Last Entry Date"), 2)
        #set up the torrents list viewer
        self.torrents_view = glade.get_widget("torrents_view")
        model = gtk.ListStore(str, str, str, str)
        self.torrents_view.set_model(model)
        deluge.dgtk.add_text_column(self.torrents_view, _("Feed"), 0)
        deluge.dgtk.add_text_column(self.torrents_view, _("Name"), 1)
        deluge.dgtk.add_text_column(self.torrents_view, _("URL"), 2)
        deluge.dgtk.add_text_column(self.torrents_view, _("Date"), 3)
        # Setup the filters list viewer
        self.filters_view = glade.get_widget("filters_view")
        model = gtk.ListStore(str)
        self.filters_view.set_model(model)
        deluge.dgtk.add_text_column(self.filters_view, _("Name"), 0)
        # set up the feed choice combobox
        self.feedchoice_combo = glade.get_widget("feedchoice_combo")
        model = gtk.ListStore(str)
        self.feedchoice_combo.set_model(model)
        cell = gtk.CellRendererText()
        self.feedchoice_combo.pack_start(cell, True)
        self.feedchoice_combo.add_attribute(cell, 'text', 0) 
        # set up the torrents feed choice combobox
        self.torrents_fcc = glade.get_widget("torrents_fcc")
        model = gtk.ListStore(str)
        self.torrents_fcc.set_model(model)
        cell = gtk.CellRendererText()
        self.torrents_fcc.pack_start(cell, True)
        self.torrents_fcc.add_attribute(cell, 'text', 0) 
        #set up the rest of the GUI elements
        self.name_entry = glade.get_widget("name_entry")        
        self.url_entry = glade.get_widget("url_entry")
        self.button_addfeed = glade.get_widget("button_addfeed")
        self.button_delfeed = glade.get_widget("button_delfeed")
        self.chkfeeds = glade.get_widget("chkfeeds")
        self.filtername_entry = glade.get_widget("filtername_entry")
        self.filterexp_entry = glade.get_widget("filterexp_entry")
        self.button_delfilter = glade.get_widget("button_delfilter")
        self.checkonstart_button = glade.get_widget("checkonstart_button")
        self.update_entry = glade.get_widget("update_entry")
        #Connect event signals
        self.filters_view.connect("cursor-changed", self.filter_row_clicked)
        dic = {    "addfeed_clicked" : self.addfeed_clicked,
                "delfeed_clicked" : self.delfeed_clicked,
                "addfilter_clicked" : self.addfilter_clicked,
                "delfilter_clicked" : self.delfilter_clicked,
                "row_clicked" : self.row_clicked,
                "feedtext_changed" : self.feedtext_changed,
                "filtername_lostfocus" : self.filtername_lostfocus,
                "filterexp_lostfocus" : self.filterexp_lostfocus,
                "feedchoice_combo_changed" : self.feedchoice_combo_changed,
                "torrents_fcc_changed" : self.torrents_fcc_changed,
                "torrents_view_row_activated" : self.torrents_view_row_activated,
                "chkfeeds_clicked" : self.chkfeeds_clicked,
                "cancel_clicked" : self.dialog_cancel,
                "ok_clicked" : self.dialog_ok }
        glade.signal_autoconnect(dic)
        self.feeds_view.get_selection().set_select_function(self.row_clicked)
        self.timer = 0
        self.torrents_list = []
        #self.checkfeeds()
        # Access the interface's toolbar
        self.toolbar = self.interface.toolbar
        # Make a toolbar button
        icon = gtk.Image()
        icon.set_from_file(self.path + "/rss.png") # Toolbar items should be 22x22 pixel images
        self.button = gtk.ToolButton(icon_widget=icon, label=_("RSS"))
        self.ttips = gtk.Tooltips()
        self.button.set_tooltip(self.ttips, _("SimpleRSS Broadcatcher"))
        self.button.connect("clicked", self.rss_clicked) # Connect the signal handler for the button
        self.toolbar.add(self.button) # Add button to toolbar
        self.button.show_all() # Show the button
        self.checkonstart = False
        #load options
        if self.feeds_config.has_option("DEFAULT", "interval"):
            self.interval = self.feeds_config.getint("DEFAULT", "interval")
            self.update_entry.set_text(self.feeds_config.get("DEFAULT", "interval"))
        else:
            self.interval = 900
            self.feeds_config.set("DEFAULT", "interval", 900)
        if self.feeds_config.has_option("DEFAULT", "checkonstart"):
            self.checkonstart = self.feeds_config.getboolean("DEFAULT", "checkonstart")
            self.checkonstart_button.set_active(self.checkonstart)
        else:
            self.checkonstart = False
            self.feeds_config.set("DEFAULT", "checkonstart", False)
        if self.checkonstart_button.get_active():
            self.timer = self.interval - 5

    def rss_clicked(self, button):
        self.configure(self)
    
    def unload(self):
        self.toolbar.remove(self.button) # Remove the button from the toolbar
        f = open(self.feeds_file, "w")
        self.feeds_config.write(f)
        f.close()
    
    def feedtext_changed(self, args):
        a = (self.name_entry.get_text() != "")
        b = (self.url_entry.get_text() != "")
        if(a and b):
            self.button_addfeed.set_sensitive(1)
        else:
            self.button_addfeed.set_sensitive(0)

    def addfeed_clicked(self, args):
        self.feeds_view.get_model().append([self.name_entry.get_text(),
                    self.url_entry.get_text(), ""])
        self.feedchoice_combo.append_text(self.name_entry.get_text())
        self.torrents_fcc.append_text(self.name_entry.get_text())
        self.feeds_config.add_section(self.name_entry.get_text())
        self.feeds_config.set(self.name_entry.get_text(), "url", self.url_entry.get_text())
        self.feeds_config.set(self.name_entry.get_text(), "lastchecked", "")
        self.name_entry.set_text("")
        self.url_entry.set_text("")

    def delfeed_clicked(self, args):
        (model, selection) = self.feeds_view.get_selection().get_selected()
        text = self.feeds_view.get_model().get_value(selection, 0)
        model2 = self.feedchoice_combo.get_model()
        model3 = self.torrents_fcc.get_model()
        the_iter = model2.get_iter_first()
        print text
        while the_iter is not None:
            print model2.get_value(the_iter, 0)
            if (model2.get_value(the_iter, 0) == text):
                remove_iter = the_iter
            the_iter = model2.iter_next(the_iter)
        model2.remove(remove_iter)
        the_iter = model3.get_iter_first()
        while the_iter is not None:
            print model3.get_value(the_iter, 0)
            if (model3.get_value(the_iter, 0) == text):
                remove_iter = the_iter
            the_iter = model3.iter_next(the_iter)
        model3.remove(remove_iter)
        model.remove(selection)
        for filt in self.filters_config.sections():
            if self.filters_config.get(filt, "feed") == text:
                self.filters_config.set(filt, "feed", "All")
        self.feeds_config.remove_section(text)
        self.button_delfeed.set_sensitive(0)
        
    def row_clicked(self, args):
        self.button_delfeed.set_sensitive(1)
        return True

    def addfilter_clicked(self, args):
        unique = True
        for filt in self.filters_config.sections():
            if filt == _("New Filter"):
                unique = False

        if unique:
            self.current_filter = _("New Filter")
            self.filters_config.add_section(_("New Filter"))
            new_iter = self.filters_view.get_model().append([_("New Filter")])
            self.filters_view.get_selection().select_iter(new_iter)
            self.filters_config.set(_("New Filter"), "filterexp", "")
            self.filters_config.set(_("New Filter"), "feed", "All")
            self.filtername_entry.set_text(_("New Filter"))
            self.feedchoice_combo.set_active(0)

            self.filtername_entry.set_sensitive(1)
            self.filterexp_entry.set_sensitive(1)
            self.feedchoice_combo.set_sensitive(1)
            self.filterexp_entry.set_text("")
            self.filtername_entry.grab_focus()
            self.button_delfilter.set_sensitive(1)

    def delfilter_clicked(self, args):
        model, selection = self.filters_view.get_selection().get_selected()
        self.filters_config.remove_section(self.current_filter)
        model.remove(selection)
        self.current_filter = None

        self.filtername_entry.set_text("")
        self.filterexp_entry.set_text("")
        self.feedchoice_combo.set_active(-1)
        self.filtername_entry.set_sensitive(0)
        self.filterexp_entry.set_sensitive(0)
        self.feedchoice_combo.set_sensitive(0)
        self.button_delfilter.set_sensitive(0)

    def filter_row_clicked(self, widget):
        selection = self.filters_view.get_selection()
        model, selection_iter = selection.get_selected()
        print model
        print selection_iter
        self.current_filter = self.filters_view.get_model().get_value(selection_iter, 0)
        self.filtername_entry.set_text(self.current_filter)
        self.filterexp_entry.set_text(self.filters_config.get(self.current_filter, "filterexp"))
        feed = self.filters_config.get(self.current_filter, "feed")
        model2 = self.feedchoice_combo.get_model()
        the_iter = model2.get_iter_first()
        while the_iter is not None:
            #print model2.get_value(the_iter, 0)
            if (model2.get_value(the_iter, 0) == feed):
                set_iter = the_iter
            the_iter = model2.iter_next(the_iter)
        self.feedchoice_combo.set_active_iter(set_iter)

        self.filtername_entry.set_sensitive(1)
        self.filterexp_entry.set_sensitive(1)
        self.feedchoice_combo.set_sensitive(1)
        self.button_delfilter.set_sensitive(1)

    def filtername_lostfocus(self, args, spare):
        (model, selection) = self.filters_view.get_selection().get_selected()
        old_filtername = self.filters_view.get_model().get_value(selection, 0)
        self.filters_config.remove_section(old_filtername)
        model.remove(selection)

        self.current_filter = self.filtername_entry.get_text()
        new_iter = self.filters_view.get_model().append([self.current_filter])
        self.filters_view.get_selection().select_iter(new_iter)
        self.filters_config.add_section(self.current_filter)
        self.filters_config.set(self.current_filter, "filterexp", self.filterexp_entry.get_text())
        self.filters_config.set(self.current_filter, "feed", self.feedchoice_combo.get_active_text())

    def filterexp_lostfocus(self, args, spare):
        self.filters_config.set(self.current_filter, "filterexp", self.filterexp_entry.get_text())

    def feedchoice_combo_changed(self, args):
        self.filters_config.set(self.current_filter, "feed", self.feedchoice_combo.get_active_text())

    def torrents_fcc_changed(self, args):
        model = self.torrents_view.get_model()
        model.clear()
        if self.torrents_fcc.get_active_text() == _("All"):
            for (date, feed, title, link) in self.torrents_list:
                self.torrents_view.get_model().append((feed, title, link, date))
        else:
            for (date, feed, title, link) in self.torrents_list:
                if feed == self.torrents_fcc.get_active_text():
                    self.torrents_view.get_model().append((feed, title, link, date))

    def torrents_view_row_activated(self, widget, spare1, spare2):
        selection = widget.get_selection()
        model, selection_iter = selection.get_selected()
        self.interface.interactive_add_torrent_url(widget.get_model().get_value(selection_iter, 2))
        

    def chkfeeds_clicked(self, args):
        self.checkfeeds()

    def checkfeeds(self):
        import feedparser, datetime
        from time import asctime, strptime

        avail = {}
        sorted = {}
        self.torrents_list = []
        for name in self.feeds_config.sections():
            print "Attempting to parse " + name
            tmp = feedparser.parse(self.feeds_config.get(name, "url"))
            try:
                print "Parsed " + tmp['feed']['title']
                avail[name] = True
            except:
                print "Failed to download/parse " + name
                avail[name] = False
            if avail[name]:
                entries = []
                entries.extend( tmp[ "items" ] )
                decorated = [(entry["date_parsed"], entry) for entry in entries]
                tmplist = [(entry["date_parsed"], name, entry["title"], entry.enclosures[0].href) for entry in entries]
                decorated.sort()
                self.torrents_list.extend(tmplist)
                #decorated.reverse() # for most recent entries first
                sorted[name] = [entry for (date,entry) in decorated]

        model = self.torrents_view.get_model()
        model.clear()
        self.torrents_list.sort()
        self.torrents_list.reverse()
        #self.torrents_view.get_model().append([entry for entry in self.torrents_list])
        for (date,feed,title,link) in self.torrents_list:
            self.torrents_view.get_model().append((feed, title, link, date))
        #for key in sorted.keys():
        #    print "listing entries in " + key
        #    
        #    for entry in sorted[key]:
        #        print entry.title
        #        for enclosure in entry.enclosures:
        #            self.torrents_view.get_model().append( (key, entry.title, enclosure.href, entry.date_parsed) )

        checked = {}
        for name in self.filters_config.sections():
            checkfiltername = name
            checkfilterexp = self.filters_config.get(name, "filterexp")
            checkfilterfeed = self.filters_config.get(name, "feed")
            print "filter: " + checkfiltername
            print "search: " + checkfilterexp
            print "feed: " + checkfilterfeed
            if checkfilterfeed == "All":
                #print "made it to 'All'"
                for feedname in sorted.keys():
                    if avail[feedname]:
                        print feedname + " last checked: " + self.feeds_config.get(feedname, "lastchecked")
                        if self.feeds_config.get(feedname, "lastchecked") != "":
                            lastchecked = strptime(self.feeds_config.get(feedname, "lastchecked"))
                        else:
                            lastchecked = strptime(asctime(sorted[feedname][0].date_parsed))
                        #print "searching feed: " + feedname
                        for entry in sorted[feedname]:
                            #print entry.title + ": " + asctime(entry.date_parsed)
                            if (strptime(asctime(entry.date_parsed)) > lastchecked):
                                #print entry.date_parsed
                                #print " > "
                                #print lastchecked
                                if entry.title.find(checkfilterexp) != -1:
                                    #print "contains" + checkfilterexp
                                    for enclosure in entry.enclosures:
                                        print enclosure.href
                                        self.interface.interactive_add_torrent_url(enclosure.href)
                                        #self.feeds_config.set(feedname, "lastchecked", asctime(entry.date_parsed))
            else:
                if avail[checkfilterfeed]:
                    print "searching feed: " + checkfilterfeed
                    if self.feeds_config.get(checkfilterfeed, "lastchecked") != "":
                        lastchecked = strptime(self.feeds_config.get(checkfilterfeed, "lastchecked"))
                    else:
                        #print sorted[checkfilterfeed][1].date_parsed
                        lastchecked = strptime(asctime(sorted[checkfilterfeed][0].date_parsed))
                    print "lastchecked: " + asctime(lastchecked)
                    for entry in sorted[checkfilterfeed]:
                        #print entry.title + ": " + asctime(entry.date_parsed)
                        if (strptime(asctime(entry.date_parsed)) > lastchecked):
                            #print entry.date_parsed
                            #print " > "
                            #print lastchecked
                            if (entry.title.find(checkfilterexp) != -1):
                                #print "contains" + checkfilterexp
                                for enclosure in entry.enclosures:
                                    print enclosure.href
                                    self.interface.interactive_add_torrent_url(enclosure.href)
                                    #self.feeds_config.set(checkfilterfeed, "lastchecked", asctime(entry.date_parsed))

        for name in avail.keys():
            if avail[name]:
                self.feeds_config.set(name, "lastchecked", asctime(sorted[name][len(sorted[name])-1].date_parsed))

        self.timer = 0




    def configure(self, widget=None):
        import gtk, gtk.glade
        from deluge import common
        self.dlg.show_all()
        model = self.feeds_view.get_model()
        model.clear()
        model2 = self.feedchoice_combo.get_model()
        model2.clear()
        model3 = self.filters_view.get_model()
        model3.clear()
        model4 = self.torrents_fcc.get_model()
        model4.clear()
        self.filtername_entry.set_text("")
        self.filterexp_entry.set_text("")
        self.name_entry.set_text("")
        self.url_entry.set_text("")
        self.feedchoice_combo.append_text(_("All"))
        self.torrents_fcc.append_text(_("All"))
        self.torrents_fcc.set_active(0)
        for name in self.feeds_config.sections():
            self.feeds_view.get_model().append( (name, self.feeds_config.get(name, "url"), self.feeds_config.get(name, "lastchecked") ) )
            self.feedchoice_combo.append_text(name)
            self.torrents_fcc.append_text(name)
        for filters in self.filters_config.sections():
            self.filters_view.get_model().append( ([filters]) )
        #self.checkfeeds()
        self.button_addfeed.set_sensitive(0)
        self.button_delfeed.set_sensitive(0)
        self.filtername_entry.set_sensitive(0)
        self.filterexp_entry.set_sensitive(0)
        self.feedchoice_combo.set_sensitive(0)
        self.button_delfilter.set_sensitive(0)
        self.update_entry.set_text(str(self.interval))
        self.checkonstart_button.set_active(self.checkonstart)

    def dialog_ok(self, source):
        self.dlg.hide_all()
        self.interval = int(self.update_entry.get_text())
        self.feeds_config.set("DEFAULT", "interval", self.update_entry.get_text())
        self.feeds_config.set("DEFAULT", "checkonstart", self.checkonstart_button.get_active())
        f = open(self.filters_file, "w")
        self.filters_config.write(f)
        f.close()
        f = open(self.feeds_file, "w")
        self.feeds_config.write(f)
        f.close()

    def dialog_cancel(self, source):
        self.dlg.hide_all()

    def update(self):
        self.timer += 1
        if self.timer >= self.interval:
            import threading

            print "BONG!"
            threading.Thread(target=self.checkfeeds).start
            self.timer = 0