learning python » rss reader

RSS reader – Part Four – Integrating with the GUI

selsine — Sun, 05 Mar 2006 19:25:50 +0000

So far our RSS reader has been completely command-line, which is functional but not as nice as we’d really like to have it. So what we are going to do is integrate the GUI that I created in my two Tkinter GUI tutorials into our RSS application.

If you look at our GUI application you can see that at this point it actually has the basic look that we’ll want, what it doesn’t have is the functionality attached to to GUI. So the first thing that we are going to do is let the user add an RSS site when the press the Add button. We are going to pop up a dialog and let them enter the name of the RSS site and the address of the RSS feed.

In order to do that we are going to have to create a simple dialog. Fortunately Tkinter has a nice simple dialog interface that makes creating simple pop-up dialogs quite easy. It’s not as robust as you might like, but if you really wanted to do something very complicated you could simply create another window in the same way that we created our main window. Since we don’t need anything fancy we”ll use the Simple dialog.

To start we must import the simple dialog into our program, so the following will have to be added to the top of the code:

import tkSimpleDialog

Now we could create create our dialog class in a totally new python file but since it’s going to be pretty simple I decided to keep all together in our one GUI file. The first step in understanding the simple dialog is to read PythonWare’s introduction to the dialog window it will explain all that you need to know to create a simple dialog.

Basically what you need to do is create a class whose parent is the simple dialog:

class RSSItemDialog(tkSimpleDialog.Dialog):

Then you have to create a body function, this is the function that the tkSimpleDialog assumes will be used to create the body of the dialog. The definition of the body function is as follows:

def body(self, master):

Pretty simple so far right? There are a few other important functions that you need to know about to create a simple dialog, like when to process the data after the Ok button is pressed:

def apply(self):

When the cancel or Ok button is pressed:

def cancel(self, event):
def ok(self, event):

You can read this documentation on sourceforge is you need to know more. For our simple dialog we only care about the body and apply functions. The only other feature that I wanted to add to this dialog was a simple way to set the default values of the RSS name and RSS Feed URL.

That way it would be easy to use this dialog to add and edit RSS sites. To do so you have add and __init__ function to the class, it is defined as:

def __init__(self, parent, title=None, RSSName="", RSSUrl=""):

Where self, parent, and title are the parameters expected by tkSimpleDialog, title being the dialogs title, and RSSName and RSSUrl our new parameters. So here is the RSSDialog’s code in it’s entirety, if you are familiar with tkInter at all it should be pretty simple, if you have any questions ask them and I will try to answer them:

class RSSItemDialog(tkSimpleDialog.Dialog):

    def __init__(self, parent, title=None, RSSName="", RSSUrl=""):
        """Init, override default for default params"""
        self.RSSName = RSSName
        self.RSSUrl = RSSUrl
        self.Result = False #Default = Cancel
        tkSimpleDialog.Dialog.__init__(self, parent,title)
        
    def body(self, master):
        """This is where you create the Body of the dlg"""
 
        lbText = Label(master, text="Name")
        lbText.grid(row=0, padx=5, pady=10,sticky=W)
        lbText = Label(master, text="URL:")
        lbText.grid(row=1, padx=5,sticky=W)

        self.eRSSName = Entry(master)
        self.eRSSName.insert(0,self.RSSName)
        self.eRSSUrl = Entry(master)
        self.eRSSUrl.insert(0,self.RSSUrl)

        self.eRSSName.grid(row=0, column=1)
        self.eRSSUrl.grid(row=1, column=1)
        
        """Return the widget that will get focus"""
        return self.eRSSName

    def apply(self):
        """They have selected OK"""
        self.Result = True
        self.RSSName = (self.eRSSName.get())
        self.RSSUrl = (self.eRSSUrl.get())

Now we need to do a few things, we need to save a list of RSS sites in our GUIFramework class, this will correspond to the list of items in the Listbox. To do so we add the following code to the __init__ function:

self.lstSites = []

This is a list of RSS sites that the user has added to our application. We will also need a new class to contain all of the RSSSite information, the class is pretty simple:

class RSSSite:
    """An RSS Site"""
    def __init__(self, Name="", Url=""):
        self.Name = Name
        self.Url = Url

Then we have to create a function that will correspond to when the Add button is pressed. This dialog will show the RSSItemDialog and then if Ok is press add the resulting RSSSite to the RSS Site Listbox (lbSites) and store the site in the lstSites list. The code to accomplish this is as follows:

def AddRSSItem(self):
    """Add an RSSItem"""
    
    RSSDlg = RSSItemDialog(self.master,"Add new Item")
    if (RSSDlg.Result):
        newSite = RSSSite(RSSDlg.RSSName
                           , RSSDlg.RSSUrl)
        self.lbSites.insert(END, RSSDlg.RSSName)
        self.lbSites.select_clear(0,END)
        self.lbSites.select_set(END)
        self.lstSites.append(newSite)

So we create the new dialog, and then if the user clicks Ok (Result == True) we create a new site. Then we add the sites name to the end of the lbSites listbox, clear any current selection, and then select what we just added. After that we simply add the RSS site to our site list. So the position of the RSS Sites name in the lbSites ListBox corresponds to the RSSSite’s position in the lstSites list. It’s basically like a simple mapping, I would rather store all of the information in the Listbox but I couldn’t find anyway to do that.

We will use that same basic formula to create the EditRSSItem function, but instead of creating a new RSSSite we need to edit the selected RSSSite:

def EditRSSItem(self):
    """Edit an RSSItem"""  
    """Get the Current selection"""
    lstCurrSel = self.lbSites.curselection();
               
    if (len(lstCurrSel)>0):
        selected_site = self.lstSites[int(lstCurrSel[0])]
        RSSDlg = RSSItemDialog(self
                                ,"Edit"
                                , selected_site.Name
                                , selected_site.Url)
        if (RSSDlg.Result):
            """Update the ListBox"""
            self.lbSites.delete(lstCurrSel)
            self.lbSites.insert(lstCurrSel, RSSDlg.RSSName)
            self.lbSites.select_clear(0,END)
            self.lbSites.select_set(lstCurrSel)
            
            """Save the values in the list"""
            self.lstSites[int(lstCurrSel[0])] =  RSSSite(RSSDlg.RSSName
                           , RSSDlg.RSSUrl)

The only confusing code that you might see is this int(lstCurrSel[0]), which is basically converting the first value in the selection list to an integer. We need to do this because list in python expect integers for indices. So we get the current selected index in the ListBox and then use that to get the RSSSite from our list. Then the rest of the process is almost identical to the AddRSSItem function.

Now we need to hook the two functions up to our buttons:

self.btnAdd = Button(self, text="Add", command=self.AddRSSItem)
self.btnEdit = Button(self, text="Edit", command=self.EditRSSItem)

You can probably guess what the next step in the equation is, we need to make it so that our View button displays all of the RSS items in the lbRSSItems ListBox. To do this we are going to need to bring in the RSSGenerator.py code that we created in part three. Instead of taking all the code from that file and then adding it to our current file (which we could do) we are simple going to move that file into the same directory as our current python file (mine is called GUI.py) then we have to import or include the RSSGenerator.py classes:

from RSSGenerator import *

Then we have to create a ViewRSSItems function, which is very similar to our EditRSSItem function except that it will fill the lbRSSItems ListBox with all of the current RSS items available on the feed:

def ViewRSSItems(self):
    """Get the Current selection"""
    lstCurrSel = self.lbSites.curselection();
               
    if (len(lstCurrSel)>0):
        selected_site = self.lstSites[int(lstCurrSel[0])]
        """Empty the ListBox"""
        self.lbRSSItems.delete(0, END)
        rss_reader = RSSReader(selected_site.Url)
        for rss_item in rss_reader.GetItems():
            if (rss_item):
                self.lbRSSItems.insert(END,rss_item.title)
                self.lstItems.append(rss_item)

So we get the current selection, then we create our RSSReader based upon the RSSSites Url. Then we loop through the RSSItems adding each to our ListBox and to our list of the items (lstItems) that we have added in out GUIFramework’s __init__ function:

self.lstItems = []

As you can see the RSS Reader is actually starting to take shape, now all we have to do is show the RSS Items description in the text widget when we click the Set Text button. Given all the ListBox processing that we have done recently the way that this works should come as no surprise:

def SetStoryText(self):
    """Set the Story text, called form the btnSetText""" 
    """Get the Current selection"""
    lstCurrSel = self.lbRSSItems.curselection();
               
    if (len(lstCurrSel)>0):
        rss_item = self.lstItems[int(lstCurrSel[0])]
        """Set the Text Widgets text"""
        self.txtItem.config(state=NORMAL)
        self.txtItem.delete(1.0,END)
        self.txtItem.insert(INSERT, rss_item.description + "\r\n\r\n")
        self.txtItem.insert(INSERT, rss_item.link, "a")
        self.txtItem.config(state=DISABLED)

Whew that’s a lot of code this time, but none of it is really that new or that difficult if you have been following along with the RSS Reader so far. You might notice that I have not gone into great detail describing all of the code. The reason for that is because for the most part I’ve already gone over the code in detail in a previous post, or the code is sufficiently similar to code I have gone over that I don’t think that it needs a great deal of description. But if you have any questions about any of the code that I have shown above feel free to ask a question and I will be happy to explain it in more detail.

The next step in the RSS Read will be to save and load the RSSSites into a file so that we don’t have to waste our time typing them in every time we start the program, but I’ll leave that for another day.

You can download all the code used in this post here: RSSPart4.zip

RSS reader – Part Three – Generator Class

selsine — Tue, 31 Jan 2006 04:51:01 +0000

Please remember to read part one and part two.

Classes and Generators

All right, now that we have split our RSS reader up into functions, we’re going to go one step further and put our code into a class.

We’re also going to do something a bit more advanced with our class and create a generator. The reason that we are going to do this is because python has such nice iteration handling and because in the future we’ll probably want to handle each RSS item individually rather then simply dumping it out to the terminal.

Generators are basically a type of iterator, except their syntax is slightly different. In fact anything you can accomplish in a generator you can accomplish in a standard iterator.

Here is an example generator that yields all the factors of the specified number:

def factors (num):
	count = 1;
	while count < = num/2:
		if (num % count == 0):
			yield count
		count = count + 1
	yield num

The special statements that make this function a generator are those two yield statements. (The second yield statement is simply to return the number itself, since a number is always a factor of itself.) The yield statement basically returns the data to the caller and the next time the function is iterated on, the function continues exactly where it left off.

You call the generator in the following way:

for res in factors(30):
	print res

With the following results:

1 2 3 5 6 10 15 30


Code
As you can see having something like this would be very useful in our RSS reader.  In order to accomplish this the first new addition to the code that we created in part two  is the RSSItem class.  The RSSItem class basically represents one RSS item.  For the time being it is going to contain only the title and the description.  The nice thing about having this in a separate class is that we can add new members at any time without affecting existing code:
class RSSItem:
	"""This is an RSS item, it contain all the RSS info like Tile and Description"""
	def __init__(self,title="",description=""):
		self.title = title
		self.description = description
You'll notice that the RSSItem class has no functions besides the __init__ which takes two optional parameters the title and the description, and then sets two data members equal to those values.
The next thing that we are going to define is out main class, we'll call it RSSReader for lack of a better name:
class RSSReader:
	"""This class is an RSS reader, it should have a better docstring"""
Here is the __init__ function, which takes one parameter, the RSSUrl.  The __init__ function also does some "pre-processing" and gets the XML document:
def __init__(self,RSSUrl):
	"""Initialize the class"""
	self.RSSUrl = RSSUrl;
	self.xmldoc = self.GetXMLDocument(RSSUrl)
	if (not self.xmldoc):
		print "Error Getting XML Document!"
The RSSUrl class has two member variables, RSSUrl and xmldoc.  You'll also notice that the __init__ function calls  a member function of RSSReader called GetXMLDocument, which does exactly what it says:
def GetXMLDocument(self,RSSUrl):
	"""This function reads in a RSS URL and then"""
	"""returns the XML document on success"""
	url_info = urllib2.urlopen(RSSUrl)
	xmldoc = None
	if (url_info):
		xmldoc = minidom.parse(url_info)
	else	:
		print "Error Getting URL"
	return xmldoc
The next function that I'm going to show you is the generator, and how simply it actually is:
def GetItems(self):
	"""Generator to get items"""
	for item_node in self.xmldoc.documentElement.childNodes:
			if (item_node.nodeName == "item"):
				"""All right we have an item"""
				rss_item = self.CreateRSSItem(item_node)
				yield rss_item
You'll see that all this generator does is iterate through all of the nodes in the XML document until it comes to a node named "Item".  Once a node named "item" is encountered a member function called CreateRSSItem (Which creates an RSSItem) is called and then that RSSItem is yielded to the caller.
CreateRSSItem is another simply function:
def CreateRSSItem(self,item_node):
	"""Create an RSS item and return it"""
	title = self.GetChildText(item_node,"title")
	description = self.GetChildText(item_node,"description")
	return RSSItem(title,description)
All this function does is call the member function GetChildText for the "title" and "description" values.  GetChildText basically searches through the passed xml node's children searching for a match to the second parameter, and if one is found  that item's text is returned.

Then CreateRSS item call the constructor of the RSSItem class and returns the created class: return RSSItem(title,description)

There are only two more functions left, both of which are (as you might have guessed) very simply. This is the beauty of using functions, you get to break up the code into manageable and reusable tasks. The two functions that are left are GetChildText and GetItemText.

Where GetChildText searched through childNodes for a matching item, GetItemText simply returns an XML node’s text:

def GetItemText(self,xml_node):
	"""Get the text from an xml item"""
	text = ""
	for text_node in xml_node.childNodes:
		if (text_node.nodeType == Node.TEXT_NODE):
			text += text_node.nodeValue
	return text

def GetChildText(self, xml_node, child_name):
	"""Get a child node from the xml node"""
	if (not xml_node):
		print "Error GetChildNode: No xml_node"
		return ""
	for item_node in xml_node.childNodes:
		if (item_node.nodeName==child_name):
			return self.GetItemText(item_node)
	"""Return Nothing"""
	return ""

All that’s left is to show how we create an instance of the RSSReader class, and then use the generator to iterate through all of the RSSItems:

if __name__ == "__main__":
	rss_reader = RSSReader('http://rss.slashdot.org/Slashdot/slashdot')
	for rss_item in rss_reader.GetItems():
		if (rss_item):
			print rss_item.title
			print ""
			print rss_item.description
			print ""

Here is the code in its entirety, it call also be downloaded from here:

#! /usr/bin/env python

import urllib2
from xml.dom import minidom, Node

class RSSItem:
	"""This is an RSS item, it contain all the RSS info like Tile and Description"""
	def __init__(self,title="",description=""):
		self.title = title
		self.description = description

class RSSReader:
	"""This class is an RSS reader, it should have a better docstring"""
	
	def __init__(self,RSSUrl):
		"""Initialize the class"""
		self.RSSUrl = RSSUrl;
		self.xmldoc = self.GetXMLDocument(RSSUrl)
		if (not self.xmldoc):
			print "Error Getting XML Document!"
		
	def GetXMLDocument(self,RSSUrl):
		"""This function reads in a RSS URL and then"""
		"""returns the XML documentn on success"""
		url_info = urllib2.urlopen(RSSUrl)
		xmldoc = None
		if (url_info):
			xmldoc = minidom.parse(url_info)
		else	:
			print "Error Getting URL"
		return xmldoc
	
	def GetItemText(self,xml_node):
		"""Get the text from an xml item"""
		text = ""
		for text_node in xml_node.childNodes:
			if (text_node.nodeType == Node.TEXT_NODE):
				text += text_node.nodeValue
		return text
	
	def GetChildText(self, xml_node, child_name):
		"""Get a child node from the xml node"""
		if (not xml_node):
			print "Error GetChildNode: No xml_node"
			return ""
		for item_node in xml_node.childNodes:
			if (item_node.nodeName==child_name):
				return self.GetItemText(item_node)
		"""Return Nothing"""
		return ""
	
	def CreateRSSItem(self,item_node):
		"""Create an RSS item and return it"""
		title = self.GetChildText(item_node,"title")
		description = self.GetChildText(item_node,"description")
		return RSSItem(title,description)
	
	def GetItems(self):
		"""Generator to get items"""
		for item_node in self.xmldoc.documentElement.childNodes:
				if (item_node.nodeName == "item"):
					"""Allright we have an item"""
					rss_item = self.CreateRSSItem(item_node)
					yield rss_item
					
if __name__ == "__main__":
	rss_reader = RSSReader('http://rss.slashdot.org/Slashdot/slashdot')
	for rss_item in rss_reader.GetItems():
		if (rss_item):
			print rss_item.title
			print ""
			print rss_item.description
			print ""

RSS reader – Part Two (and Functions)

selsine — Tue, 24 Jan 2006 22:55:34 +0000

This post is my continuation of my Python based RSS reader that I wrote in part one. As I said the code written in part one is not something that you would ever really want to use or maintain since it wasn’t broken up in to functions properly. So, in this part we’re going to work on breaking the old script up into functions.

Functions

Functions are defined in python using the def keyword. So if I wanted to define a function called “count” that counts from 1 to a certain number I would do so like so:

def count(nNum):

Where count is the name of the function and nNum is a parameter that is being passed into the function. If I wanted to call the function I would do so like this:

count(10)

Here is the entire code for the count function:

def count(nNum):
    x = 1
    while x &lt: nNum :
        print x
        x = x +1

Another interesting feature that python uses are Documentation Strings, these are basically comments that help document the code for you and can also be read by documentation tools like pyDoc to create formatted documentation. Since this is becoming a standard it’s a good way for other people, and you, to be able to easily see what your program does.

So for the count function we might add something like this:

def count(nNum):
    """This function prints out the numbers from 1 to nNum"""
    x = 1
    while x &lt: nNum :
        print x
        x = x +1

The Code

We will be reusing the code that was already written in Part One for this section.

Now what we need to do is break up the code that we used in part one so that it uses functions. The first thing that we are going to do is instead of always using the same location for our RSS we are going to write a function that takes an RSS url as it parameter and then attempts to retrieve it’s RSS information. We’ll call that function GetRSS:

def GetRSS(RSSurl):
	"""This function attempts to get the RSS info using RSSurl as the RSS url"""

	url_info = urllib2.urlopen(RSSurl)
	if (url_info):
		"""We have retrieve the RSS url properly, now let's parse it up"""
		xmldoc = minidom.parse(url_info)
		if (xmldoc):
			"""Loop through all children of the main document"""
			for item_node in xmldoc.documentElement.childNodes:
				if (item_node.nodeName == "item"):	
					"""If we have found an item print out the title 
					and description"""
					PrintNodeItems(item_node, ["title","description"])
		else:
			print "Error parsing url into xml"
	else:
        	print "Error! Getting URL"

You’ll notice that GetRSS is very similar to the majority of code that we had in Part One. Basically it gets the RSS XML from a specific URL, then it loops through all of the child nodes in the XML looking for item nodes. Once an node with the name of “item” is found the following new code is called:

PrintNodeItems(item_node, ["title","description"])

This line calls another new function in the code called PrintNodeItems, passing it our item node and a list of items:

def PrintNodeItems(XmlNode, items):
	"""This function prints out all children of XmlNode found in items"""
	for item_node in XmlNode.childNodes:
		if item_node.nodeName in items:
			PrintNodesText(item_node)

PrintNodeItems is a simple function that loops through all of the childNodes found in XmlNode and check to see if the childNodes nodeName is in the list items. If it is in the list, then the function PrintNodesText is called.

def PrintNodesText(XmlNode):
	"""This function prints out an XML Nodes text nodes."""
	text = ""
	for text_node in XmlNode.childNodes:
		if (text_node.nodeType == Node.TEXT_NODE):
			text += text_node.nodeValue
	"""Noe print out the text"""
	if (len(text)>0):
		print text
		print ""

PrintNodeItems is another simple function that basically loops through an XmlNode’s children and prints out all TEXT_NODES. You’ll notice that this code is identical to the code that we used to print out the “title” and “description” nodes in Part One. The difference this time is that instead of duplicating code in two spots we simple create one function that gets called twice.

Now we have the a simple main() function that calls GetRSS:

def main():
	"""Main Function"""
	GetRSS('http://rss.slashdot.org/Slashdot/slashdot')

The final step is a method for getting the ball rolling, for starting the execution. So far we’ve simply defined functions that perform tasks when called but how do we call the first function?

The answer is a simple check at the bottom of your python script to determine if the script was launched directly as a standalone script (which is all that we have been doing so far when we call out scripts via the command line):

if __name__ == "__main__":
	main()

This is basically a way for the Python script to know if it has been launched directly, if it has not been launched directly and is been instantiated in a different manner __name__ will not equal “__main__” and the main function will not be called automatically.

RSS reader – Part One

selsine — Sat, 14 Jan 2006 19:12:03 +0000

All right so I’ve already figured out how to write an executable script that writes out “Hello World!” to the command line, now I need to figure out how to do something interesting. As a result I was surfing the Internet and reading some Python documentation, trying to come up with something to do but nothing [...]