Using Python to Update Google Sites Pages oh how I miss SSIs

First, I got the GData Python client library from https://developers.google.com/gdata/ and installed it in my home directory by finding the setup.py in the GData distribution and typing the command:

python setup.py --home=~/python/

I also ran the included tests to make sure it was all working.

GData comes with everything you need to work programmatically with information at Google.

In order for your Python program to talk to Google, you need to create an API Client ID, which you can do for free at https://code.google.com/apis/console. An API Client ID will give you a Client ID and a Client secret, both of which you'll need in your Python program.

To get started, I imported the Python libraries I knew I'd need. I learned about the required gdata libraries from the API documentation.

import sys
import os
import time
# adjust the next line for your installation of gdata
sys.path.append('/Users/acaird/python/lib/python')
import atom.data
import gdata.sites.client
import gdata.sites.data
import gdata.gauth

This block of code imports the standard Python libraries sys, os, and time, and you'll see those used later (in the case of sys, not too much later).

Next I use the sys library to tell Python where I installed the gdata library with the sys.path.append function. You will almost certainly want to edit that. You can also use the PYTHONPATH environment variable.

Once the program can find the gdata libraries, I import the ones the documentation says I'll need.

At this point, I have all of the tools I need.

The next block of source code handles the authorization of the program to make changes to a Google Sites page. The authorization is done using OAuth, an open standard and one that is well supported in the GData library². The flow of the code is:

1. Set a location for cached credentials
2. Try to open the file in that location
   1. If the file can be opened, try to read a gauth token from the file
   2. If the file cannot be opened, set the token to None
3. If there isn't a token, talk to Google to get one This process will print out a URL to be followed for authorization and ask for a key from the authorization to be entered, then authorize the client (this program, via the variable client), then save the credentials.
4. If there is a token, it is used to authorize the client

In this case, the client secret isn't a secret.³ The user_agent can be anything meaningful to you so you can look at the logs and see when your Python program changed your web content and when a person changed it.

You'll notice in this code block we create the variable client; in that creation we also select the Google Site we want to edit, in this case it is confusingly called the same as my name, acaird. I suspect, but don't know for sure, you could read the sites (as below) and select from a list programmatically. In my case I know the name of the site I want to update, so I just typed it in.

The scope in the gdata.gauth.OAuth2Token function call is specific for Google Sites. For a list of other scopes, see http://googlecodesamples.com/oauth_playground/.

WARNING The file to which the token is written is important, it should be protected or removed if you aren't certain it can be kept safe.

#+NAME vars #+NAME authorization

token_cache_path=os.environ['HOME']+'/.gdata-storage'
print "Token Cache: %s" % token_cache_path
try:
   with open(token_cache_path, 'r') as f:
       saved_blob_string=f.read()
       if saved_blob_string is not None:
           token = gdata.gauth.token_from_blob(saved_blob_string)
       else:
           token = None
except IOError:
    token = None

if token == None :
   print "Getting a new token."
   token = gdata.gauth.OAuth2Token( client_id=MyClientId,
                                    client_secret=MyClientSecret,
                                    scope='https://sites.google.com/feeds/',
                                    user_agent='acaird-acexample-v1')
   url = token.generate_authorize_url(redirect_uri='urn:ietf:wg:oauth:2.0:oob')
   print 'Please go to the URL below and authorize this '
   print 'application, then enter the code it gives you.'
   print '   %s' % url
   code = raw_input("Code: ")
   token.get_access_token(code)
   client = gdata.sites.client.SitesClient(source='acaird-acexample-v1', site='acaird')
   token.authorize(client)
   saved_blob_string = gdata.gauth.token_to_blob(token)
   f=open (token_cache_path, 'w')
   f.write(saved_blob_string)
else:
   print "Using a cached token from %s" % token_cache_path
   client = gdata.sites.client.SitesClient(source='acaird-acexample-v1', site='acaird')
   token.authorize(client)

f.close()

feed = client.GetSiteFeed()
print 'Google Sites associated with your account: '
counter = 0
for entry in feed.entry:
  print '       %i   %s (%s)' % (counter,entry.title.text, entry.site_name.text)
  counter = counter + 1
print ' --- The End ---'

This section of code, when run on my account, produces this output:

Google Sites associated with your account:
       0   acaird (acaird)
       1   CD Squared Project (umcdsquared)
       2   U-M GPR Project (umichgpr)
       3   ORCI Project Site (umorciprojectsite)
       4   UM Projects (umprojectstruthkos)
 --- The End ---

Since we already selected the acaird Google Site when we initialized client, we can start fetching content from it.

I'm not sure what most of the code below does, but at the end, old contains the HTML of the first webpage in the acaird Google Site, which was my goal.

kind = 'webpage'
print 'Fetching only %s entries' % kind
uri = '%s?kind=%s' % (client.MakeContentFeedUri(), kind)
feed = client.GetContentFeed(uri=uri)

print "Fetching content feed of '%s'...\n" % client.site
feed = client.GetContentFeed()

uri = '%s?kind=%s' % (client.MakeContentFeedUri(),'webpage')
feed = client.GetContentFeed(uri=uri)

old=feed.entry[0]

To make sure we're updating the web page, here's the current date and time for later use, and comparison between the output on this screen and what is in the web page.

time = time.asctime()
print "Time: %s" % time

Then I create some new HTML, stored in old.content.html, which I could print out, but I've commented out that line.

Then I call client.Update with the feed.entry in old to update the page.

old.content.html = '''
<html:div xmlns:html="http://www.w3.org/1999/xhtml">
  <html:table cellspacing="0" border="1"
              class="sites-layout-name-one-column sites-layout-hbox">
    <html:tbody>
      <html:tr>
        <html:td class="sites-layout-tile sites-tile-name-content-1">
          <html:div dir="ltr">&#160;This is my web page.
                                    It was last updated on %s by <kbd>%s</kbd><br />
          </html:div>
        </html:td>
      </html:tr>
    </html:tbody>
  </html:table>
</html:div>
''' % (time,sys.argv[0])
# print old.content.html

updated_entry = client.Update(old)
print 'Web page updated.'