http://code.activestate.com/recipes/413137-call-a-functionmethod-x-times-per-second/

That is cool.

class example():
  def __init__(self, login=False):
      self.setting = 'A'
      print '__init__'
 
  def __enter__(self):
      print 'Entering '
      return self
 
  def __exit__(self, exctype, value, traceback):
      print 'Exiting '
 
with example() as e:
   print e.setting

The output of this script is :

__init__
Entering
A
Exiting

So __init__ is called first and then __enter__. Then the block after the with statement is executed, followed by __exit__ .

Of course you can return another object in __enter__ if necessary. In a lot of cases that might make more sense.

The problem is that there is no easy way to direct the logging to a new file for every test case. Here’s how I got around it. Firstly the setup method of my testcase object contains the following :

def setUp(self):
    self.logger = logging.getLogger('MyLogger')
    self.logger.setLevel(logging.DEBUG)
    self.log_handler = None
    self.formatter = logging.Formatter("%(asctime)s - %(name)s - %(message)s")

A logger is created and the default level is set. Then variables are set for the log_handler and formatter. These are used in the settestcasename method found below. This gets called in every test method of the testcase class. First it removes the old handler. The testcase name given as parameter is then used to create a new FileHandler. This will create and log to a new file when something is logged. This new handler is then added to the logger.

def settestcasename(self,giventestcasename,description=""):
    now=datetime.datetime.today().strftime('%Y%m%d_%H%M%S')
    if self.log_handler is not None:
        self.log_handler.close()
        self.logger.removeHandler(self.log_handler)
    filename='%s_%s.log' % (giventestcasename.replace(' ','_'), now)
    self.log_handler=logging.FileHandler(filename,'w')
    self.log_handler.setFormatter(self.formatter)
    self.logger.addHandler(self.log_handler)

The fact that the settestcasename has to be called is not ideal. but it works me. Something evil like this could be used to get the name of the current method, which can then be used as a filename. A decorator can possibly be created as well.

   mydict={'first':1, 'second':2, 'third':3}

and you want to get the values into a list with a certain order you can do this :

   mylist=[mydict['first'], mydict['second'], mydict['third']]

However, that can get a bit verbose if there are a lot of entries. For every entry you have to repeat ‘mydict’. An elegant way of solving this is using the map function :

   mylist=map(mydict.get,['first', 'second', 'third'])

This applies to ‘get’ function of mydict to each of the arguments given in the list. This ‘get’ function is the equivalent of calling mydict['some index'] .

List comprehensions can be used a lot of times instead of map. That’s the case here as well :

   mylist=[mydict[x] for x in ['first','second','third']]

This is arguably easier to understand than the version using map.

The easiest way to test your project's use of e-mail is to use a "dumb" e-mail server that receives the e-mails locally and displays them to the terminal, but does not actually send anything. Python has a built-in way to accomplish this with a single command :

python -m smtpd -n -c DebuggingServer localhost:1025

This command will start a simple SMTP server listening on port 1025 of localhost. This server simply prints to standard output all email headers and the email body.

That is cool.

One of the things added recently is the ability to download the results as a csv file. The following code snippet shows how to do this. The key thing is setting the Content-Disposition header, this tells the browser that a csv file is coming. The browser will then show a dialog box, where you can specify where you want to save the file. Otherwise the code is pretty standard Python : the standard csv module is used to create a csv file in memory in the StringIO object.

  class CsvPage(webapp.RequestHandler):
    def get(self):
      user = users.get_current_user()
      if user:
        output = StringIO.StringIO()
        writer=csv.writer(output, dialect='excel')
        query = db.GqlQuery("""SELECT *
                                 FROM Workout
                                WHERE added_by = :1
                                ORDER BY date DESC """,
                            users.get_current_user())
 
        writer.writerow(['date', 'minutes', 'distance', 'calories'])
        for workout in query:
            row=[workout.date.strftime("%x"), workout.minutes, \
                     workout.distance, workout.calories]
            writer.writerow(row)
 
        self.response.headers["Content-Type"] = "application/x-csv"
        self.response.headers['Content-Disposition'] = 'attachment;' \
                                       'filename=workouts.csv'
        self.response.out.write(output.getvalue())
        output.close()
      else:
        self.redirect(users.create_login_url(self.request.uri))

Lines with \ at the end are continued on the next line, in the standard Python fashion.

I put a small app together, which is a very simple variation on the ‘The Django Form Validation Framework on Google App Engine‘ article. It let’s you login, and store some data on workouts. On to some code :

  import cgi
  import wsgiref.handlers
  import os
 
  from google.appengine.api import users
  from google.appengine.ext import db
  from google.appengine.ext import webapp
  from google.appengine.ext.webapp import template
 
  from google.appengine.ext.db import djangoforms

Firstly, a lot of imports are done to get everything we need.

  class Workout(db.Model):
    minutes = db.IntegerProperty()
    distance = db.FloatProperty()
    calories = db.IntegerProperty()
    date = db.DateProperty(required=True)
    added_by = db.UserProperty()

Then a class is defined that is derived from a database Model base class. This will be stored in a database from Google called the Datastore. It contains fields for the minutes, the distance cycled and so on. The only mandatory field is the date. There is also a user field. This will be filled in when the user logs in. It also keeps the data private per user.

  class WorkoutForm(djangoforms.ModelForm):
    class Meta:
      model = Workout
      exclude = ['added_by']

Next, a form object is created. This is based on the model defined above, and it will not display the added_by field.

  class MainPage(webapp.RequestHandler):
    def get(self):
      user = users.get_current_user()
      if user:
        self.response.out.write('form goes here')
        self.response.out.write(WorkoutForm())
        self.response.out.write('remainder of form')
      else:
        self.redirect(users.create_login_url(self.request.uri))

The MainPage class handles request for a page. Here the get request is handled. If the user is logged in, it displays the form. If not, a redirection is done to Google’s login page.

    def post(self):
      data = WorkoutForm(data=self.request.POST)
      if data.is_valid():
        # Save the data, and redirect to the view page
        entity = data.save(commit=False)
        entity.added_by = users.get_current_user()
        entity.put()
        self.redirect('/workouts.html')
      else:
        # Reprint the form
        self.response.out.write('beginning of form')
        self.response.out.write(data)
        self.response.out.write('remainder of form')

A post request (from the form in the get method) is handled by the post method. It saves the data in the database if it is valid. If not, for example if the date is not filled here, it will display the data again with an error message.

  class WorkoutPage(webapp.RequestHandler):
    def get(self):
      user = users.get_current_user()
      if user:
        query = db.GqlQuery("SELECT * FROM Workout WHERE added_by = :1 ORDER BY date DESC",
                            users.get_current_user())
 
        workouts=[]
        for workout in query:
            workouts.append({'date': workout.date.strftime("%x"),
                             'minutes': workout.minutes,
                             'distance': workout.distance,
                             'calories': workout.calories
                            })
 
        template_values = {
          'workouts': workouts,
        }
 
        path = os.path.join(os.path.dirname(__file__), 'workout.html')
        self.response.out.write(template.render(path, template_values))
      else:
        self.redirect(users.create_login_url(self.request.uri))

The WorkoutPage class handles a get request that shows the results stored in the database. It uses a template called workout.html, which is not shown. All the necessary data is gathered and then the template is rendered with that data in the template.render call.

  def main():
    application = webapp.WSGIApplication(
                                         [('/', MainPage),
                                          ('/workouts.html', WorkoutPage),
                                          ],
                                         debug=True)
    wsgiref.handlers.CGIHandler().run(application)
 
  if __name__=="__main__":
    main()

Lastly, the URLs are setup. The mainpage is mapped to / and the WorkoutPage class to /workouts.html.

The app, which is very Web 0.1, can be found here. After you login with your Google ID, you can start logging those workouts.

A few things to remark :

• this code could do with a bit of a cleanup, which is all my fault
• the data is stored on Google’s servers. You may not like that.
• a Google ID is needed to login here (this can probably be changed)

All said and done, Google App Engine is a nice piece of work. It took about an hour to put all of this together and to upload it to the Google servers. So Google seems to have their homework about making it developer friendly. How well it will work for real apps is another matter. Only time will shows us that, and this is definitely still a beta. But it does look promising.

  SQLite is a C library that provides a lightweight disk-based database
  that doesn't require a separate server process and allows accessing
  the database using a nonstandard variant of the SQL query language.
  Some applications can use SQLite for internal data storage. It's also
  possible to prototype an application using SQLite and then port the
  code to a larger database such as PostgreSQL or Oracle.

The following code creates the database.

  import sqlite3
 
  conn = sqlite3.connect('feeds.db')
 
  c = conn.cursor()
 
  # Create table
  c.execute('''create table feeds (date text, url text)''')

Adding data can be done as follows. This adds a row to the feeds table, with the current time as a string in the date column and a HTML link in the url field.

  import sqlite3, time
 
  conn = sqlite3.connect('feeds.db')
  conn.isolation_level = None
  c = conn.cursor()
 
  # Insert a row of data
  data = ( time.strftime("%a, %d %b %Y %H:%M:%S +0000",
                                time.localtime(None) ),
              'http://www.sqlite.org/sqlite.html' )
  c.execute("""insert into feeds values ('%s','%s')""" % data )

Most Linux systems have a command line SQLite client, called sqlite3 for SQLite version 3. You can use this to open the database created in Python.

  $ sqlite3 feeds.db
  SQLite version 3.3.6
  Enter ".help" for instructions
  sqlite> select * from feeds;
  Mon, 10 Mar 2008 14:49:11 +0000|http://www.sqlite.org/sqlite.html
  sqlite> .quit

Cool, he ?

  python -c "from SimpleHTTPServer import test; test()"

This is invaluable if you have to copy some files across to another machine. It won’t work across the internet, but on a local network it can’t be beat. Yesterday I had to move a 2.4 Gig ISO file from the laptop PC to my Mac. Just put in a crossover cable, run the Python one liner and Bob’s your uncle.

BTW : the port used by default is 8000. So http://:8000 will get you to the right place.