Introducing the Jython plugin for Griffon

The Jython plugin enables compiling and running Jython code on your Griffon application. You don’t even need to install Jython manually. A Jython REPL is available with access to your Groovy/Java classes if you use:

griffon jython-repl

You can even load Jython scripts on-the-fly by putting them in MyGriffonApp/griffon-app/resources/jython!

In the rest of the article, we are going to create a simple application that mixes Griffon and Jython using the Griffon-Jython plugin.

Getting started with griffon-jython

It’s easy to setup Griffon, and you’ll find instructions here and downloads here. Once you’re done, you can create a Griffon app and install the jython plugin by typing:

griffon create-app MyGriffonApp
# Go into MyGriffonApp directory
cd !$
# Download and install the latest Jython plugin!
griffon install-plugin jython

Now that we’ve installed the Jython plugin, you can create a Jython class on your command-line:

griffon create-jython-class com.mypkg.MyJythonClass

Let’s create a Jython class that greets the user when a button is clicked.

from com.mypkg import IGreeter

class MyJythonClass(IGreeter):
  def __init__(self):
    pass

  def greet(self, who, model):
    greeting = 'Hello %s from Jython!' % str(who)
    model.setOutput(greeting)

Jython classes are exposed to Griffon using an Object Factory Pattern as suggested in the Definitive Guide To Jython, Chapter 10. Therefore, we create a Java (well, Groovy) interface that MyJythonClass will extend to allow Griffon to get at the proper method implementations. It sounds rather complicated, but it really is quite simple. Let’s create the IGreeter interface to show you what I’m talking about:

package com.mypkg

public interface IGreeter {
  // Same signature as our Jython method
  public void greet(String greetee, def model)
}

Our greet() method accepts a String (the textField input) and a model of unspecified type.

Griffon auto-generates MVC classes for you, so we can use those. You’ll find them in the MyGriffonApp/griffon-app/{models,views,controllers} directories. We are going to change those for our app! Here is the aforementioned Model:

package com.mypkg
import groovy.beans.Bindable

class MyGriffonAppModel {
    @Bindable String input = ''
    @Bindable String output = ''
}

Groovy implicitly creates get/setInput() methods and allows them to be bound (to the View textField value, e.g.). Here is that MyGriffonAppView:

package com.mypkg

application(title:'Griffon Jython Sample', pack:true, locationByPlatform:true) {
  gridLayout(cols: 1, rows: 2)
  //Note the ID on this textField
  textField(id: "input", columns: 20)
  button("Click me!", actionPerformed: controller.handleClick)
  bean(model, input: bind {input.text})
}

Finally, the most critical part of our application that will interact with our Jython class, the MyGriffonAppController:

package com.mypkg

import java.beans.PropertyChangeListener
import griffon.jython.JythonObjectFactory
import javax.swing.JOptionPane

class MyGriffonAppController {
  // Values auto-injected
  def model
  def view
  def greeter

  def mvcGroupInit(Map args) {
     // When our model output has changed, show a dialog
     model.addPropertyChangeListener("output", { evt ->
       if(!evt.newValue) return
       doLater {
         JOptionPane.showMessageDialog(app.windowManager.windows[0],
           evt.newValue, "Message from Jython", JOptionPane.INFORMATION_MESSAGE)
       }
     } as PropertyChangeListener)

     // Instantiate MyJythonClass
     JythonObjectFactory factory =
         new JythonObjectFactory(IGreeter.class, 'MyJythonClass', 'MyJythonClass')
     greeter = (IGreeter) factory.createObject()
   }

  def handleClick = { evt = null ->
    if(!model.input) return
    model.output = ""
    // invoke Jython class (outside EDT)
    doOutside {
      greeter.greet(model.input, model)
    }
  }
}

There you have it! Now we can utilize such Jython greatness as generators and list comprehensions!

Further reading

The Griffon Guide is the best place to go for Griffon documentation. You can find more comprehensive documentation for the Jython plugin on the official plugin page. As always, this stuff is completely open-source, and you can find all of the code and submit suggestions and issues at the GitHub repository.

Related posts:

1. Interview with Andres Almiray
2. Python first impressions
3. Using Groovy Categories to override operators

I can do this (and remove a DNS lookup) by updating my Feedburner count using an automated script on my server instead of having each client request it.

Using the FeedBurner Awareness API

Most of the time you only care about getting your total subscribers at the moment. The FeedBurner Awareness API is far more capable than just doing that, but we’re going to keep it simple today.

For the simple case you just need your feed ID or URI. Try:

curl -s 'https://feedburner.google.com/api/awareness/1.0/GetFeedData?uri=YOUR_FEED_NAME'

You receive an XML response like:

<?xml version="1.0" encoding="UTF-8"?>
<rsp stat="ok">
  <!--This information is part of the FeedBurner Awareness API. If you want to hide this information, you may do so via your FeedBurner Account.-->
  <feed id="foo0nbta7tscktjrgddc95gg3s" uri="EricWendelin">
    <entry date="2009-11-03" circulation="1181" hits="3901" reach="21" />
  </feed>
</rsp>

Now we just need to parse out the “circulation” which is your subscriber count.

Quick and dirty bash script

This is what I used to use until FeedBurner started returning 0s or blanks in the XML returned:

#!/bin/bash
FEED_COUNT=`curl -s https://feedburner.google.com/api/awareness/1.0/GetFeedData?uri=EricWendelin | egrep -o circulation=\"[0-9]+\" | egrep -o [0-9]+`

sed -r -i "s/(\"numsubscribers\">)[^<]+</\1$FEED_COUNT</g" /my/path/to/sidebar.php

echo $FEED_COUNT

You can use cron to replace some HTML, log the count, etc. every so often.

The Python

The Python version is much lengthier but has error checking and does not have to do file-replacement. The following is also available on GitHub for your extending pleasure ;).

#!/usr/bin/env python

# Usage: ./check_feedburner.py MyFeedName

import re, sys, urllib, fileinput
from xml.dom import minidom

API_URL = 'https://feedburner.google.com/api/awareness/1.0/GetFeedData?uri=%s'
# To replace the feed count in a file, put it here
FEED_COUNT_FILE = '/path/to/your/file.php'
# HTML to replace with feed count - REPLACE ME
HTML_REGEX = r'("numsubscribers">)[^<]+<'
REPLACE_STRING = r'"numsubscribers">%s<'

def get_circulation(feed_uri):
    dom = minidom.parse(urllib.urlopen(API_URL % feed_uri))
    entry = dom.getElementsByTagName('entry')[0]
    count = entry.getAttribute('circulation')
    if count == '' or count == '0':
     print 'Error getting feed count'
     sys.exit(1)
    return count

def replace_feedburner_count(count):
    '''Replaces feedburner count in FEED_COUNT_FILE'''
    try:
        for line in fileinput.input(FEED_COUNT_FILE, inplace=1):
     # Comma at the end prevents explicitly writing a newline
            print re.sub(HTML_REGEX, REPLACE_STRING % count, line, 1),
    except OSError, ose:
     print 'File "%s" not found' % FEED_COUNT_FILE

if __name__ == '__main__':
    # First arg is URI
    feed_count = get_circulation(sys.argv[1])
    print feed_count
    if FEED_COUNT_FILE:
        replace_feedburner_count(feed_count)

Something like this would be especially cool if you could set thresholds or use optparse for advanced options. Useful? Hope so!

Related posts:

1. Python first impressions
2. Site monitoring with Python and cron
3. Javascript Stacktrace update

While browsing my GitHub account I came across Mark Sanborn‘s site monitoring script and thought: “Hey this is a good idea, let’s see what I can make of it”. I have been meaning to post more Python here so I updated his code a bit and thought I’d share it with you. I hope you have ideas for improvements.

UPDATE: It looks like Mark has made this a full project on GitHub and added timing the requests and command-line options! This is a perfect example of how OSS projects are started. Check out his introductory post.

Checking site availability with Python

I didn’t feel that this script was big enough to go full OO with it, but if you want to add to it, fork the gist on GitHub and provide a link in the comments. You know what’d really be cool is if someone used timeit to get the response time and set thresholds for when the site is too slow.

#!/usr/bin/env python

# sample usage: checksites.py yoursite.com othersite.org

import pickle, os, sys, logging
from httplib import HTTPConnection, socket
from smtplib import SMTP

def email_alert(message, status):
    fromaddr = 'you@gmail.com'
    toaddrs = 'yourphone@txt.att.net'

    server = SMTP('smtp.gmail.com:587')
    server.starttls()
    server.login('you', 'password')
    server.sendmail(fromaddr, toaddrs, 'Subject: %s\r\n%s' % (status, message))
    server.quit()

def get_site_status(url):
    response = get_response(url)
    try:
        if getattr(response, 'status') == 200:
            return 'up'
    except AttributeError:
    	pass
    return 'down'

def get_response(url):
    '''Return response object from URL'''
    try:
        conn = HTTPConnection(url)
        conn.request('HEAD', '/')
        return conn.getresponse()
    except socket.error:
    	return None
    except:
        logging.error('Bad URL:', url)
        exit(1)

def get_headers(url):
    '''Gets all headers from URL request and returns'''
    response = get_response(url)
    try:
        return getattr(response, 'getheaders')()
    except AttributeError:
    	return 'Headers unavailable'

def compare_site_status(prev_results):
    '''Report changed status based on previous results'''

    def is_status_changed(url):
    	status = get_site_status(url)
    	friendly_status = '%s is %s' % (url, status)
    	print friendly_status
    	if url in prev_results and prev_results[url] != status:
            logging.warning(status)
            # Email status messages
            email_alert(str(get_headers(url)), friendly_status)
        prev_results[url] = status

    return is_status_changed

def is_internet_reachable():
    '''Checks Google then Yahoo just in case one is down'''
    if get_site_status('www.google.com') == 'down' and get_site_status('www.yahoo.com') == 'down':
        return False
    return True

def load_old_results(file_path):
    '''Attempts to load most recent results'''
    pickledata = {}
    if os.path.isfile(file_path):
        picklefile = open(file_path, 'rb')
        pickledata = pickle.load(picklefile)
        picklefile.close()
    return pickledata

def store_results(file_path, data):
    '''Pickles results to compare on next run'''
    output = open(file_path, 'wb')
    pickle.dump(data, output)
    output.close()

def main(urls):
    # Setup logging to store time
    logging.basicConfig(level=logging.WARNING, filename='checksites.log',
            format='%(asctime)s %(levelname)s: %(message)s',
            datefmt='%Y-%m-%d %H:%M:%S')

    # Load previous data
    pickle_file = 'data.pkl'
    pickledata = load_old_results(pickle_file)

    # Check sites only if Internet is_available
    if is_internet_reachable():
    	status_checker = compare_site_status(pickledata)
    	map(status_checker, urls)
    else:
        logging.error('Either the world ended or we are not connected to the net.')

    # Store results in pickle file
    store_results(pickle_file, pickledata)

if __name__ == '__main__':
    # First arg is script name, skip it
    main(sys.argv[1:])

Basically, this script just checks if the internet is available, then checks each site. If the previous result is available and is different, it sends an email with the headers received so you might get a good idea what’s going on. Even cooler, you can use the email specific to your cell phone carrier to get text messages when your sites’ availability changes.

NOTE: You must have some sort of mailer daemon installed. See How to setup Gmail with sSMTP. You can try it out by editing the appropriate parts of the script and then doing:

chmod +x checksites.py
./checksites.py eriwen.com yoursite.com

Scheduling it up with cron

I’ve already showed you the ins and outs of basic cron scheduling. We can have this run every 5 minutes by typing crontab -e and then adding:

*/5 * * * * ./path/to/checksites.py yourwebsite.com othersite.org

What do you think? Tell me how you’d make it more “pythonic” or otherwise improve it in the comments.

Related posts:

1. Using Python to update your FeedBurner stats
2. Python first impressions
3. Get groovy for better shell scripts

Good resources I’ve found

I have found some good resources online for Python and Jython, but I know I didn’t find them all so if you Python-istas could put some in the comments I’d be very grateful :)

1. The somewhat famous Python is not Java article
2. Python Documentation Index
3. Python 2.6.1 Docs
4. Python Language Notes by Chris Rathman
5. The Jython Project

What I like so far

I like that a lot of common operations are very easy. Take for example:

# 3 Hellos in Python
hellos = 'Hello ' * 3

as opposed to

// 3 Hellos in Java
String hellos = "";
for (int i = 0; i < 3; i++) {
    hellos += "Hello ";
}

There are a bunch of other features that come to mind, like string formatting, list manipulation, and variable and default-valued arguments. Oh, and of course closures are very straightforward (many thanks to Arnar for a real closure example):

def outer(your_name):
    title = random.choice(["Mr", "Mrs", "Miss"])

    def greeter(greeting):
        print greeting, title, your_name

    return greeter

g = outer("Eric")  # invoke it

# g now contains a reference to the inner
# function, but as it references variables
# from the local scope of outer, the invocation
# data has been stored in a closure
# Execution of outer is finished, but g can
# still reference its local variables through
# the closure:

g("Hi")  # prints "Hi Miss Eric" :D

I could go on and on, but you really ought to read the documentation to see all of its features. Actually there’s not all that much to it!

Troubles I have with it

I wish I could find more documentation with simple code examples. I’m sure there are a bunch of blog posts out there but it’d be nice if there were more included with the documentation.

Passing arguments by reference doesn’t seem to be possible, which is fine, but different. I’m not totally used to the lack of curly braces, but I like the fact that you must have good formatting to have runnable Python. I was surprised to learn that Python is strongly typed which in some way I think is odd because it seems like it’d be simpler if it was weakly typed.

a = "17"
b = 25
print a + b  # Nope!

One last thing is classes. I’m not sure I have my head around how they really work in Python. I’m sure I’ll get the hang of it soon.

Conclusion

Overall I’m thoroughly impressed with the language. There almost seems to be a Zen-like aura around Python code that is written with the simplicity the language creators intended.

Obviously I still have a lot to learn, so please help me out if you have some advice in the comments!

Related posts:

1. Using Python to update your FeedBurner stats
2. Site monitoring with Python and cron
3. Griffon, meet Jython