I started with the file upload tutorial in the web.py cookbook.

The problem I was getting was that the Python Image library (PIL) was failing to make the thumbnails, with the error ‘image file is truncated’.

Guessing that the upload was not yet complete when the thumbnail was initiated, I googled around for some help and came across the idea of ‘chunking’. This method copies the file upload to the destination folder in chunks as it arrives.

From this tutorial:

while 1:
        chunk = sourceFile.file.read( 10000 )
        if not chunk:
            break
        destFile.write( chunk )
    destFile.close()

I tried this method in web.py, using web.input(file = {}) to get the file field from the POST form, and then file.value.read(10000) in the code above. This fails because file.value does not have a .read() method – this is a file object method. Using file.file.read(10000) instead seems to work fine.

I’ve ended up with this:

    def POST(self, path = ''):

        self.path = path

        input = web.input(file = {})

        action = input['action']

        if action == 'upload':

            file = input['file']

            f = open(config.root + 'static/uploads/' + file.filename, "wb")

            while 1:
                chunk = file.file.read(10000 )
                if not chunk:
                    break
                f.write( chunk )
            f.close()

            self.thumbnail(path, file.filename)

        self.output()

    def thumbnail(self, path, filename):

        size = 128, 128

        outfile = open(config.root + 'static/resized/' + filename, "wb")

        im = Image.open(config.root + 'static/uploads/' + filename)
        im.thumbnail(size)
        im.save(outfile, "JPEG")

One of the great features is template inheritance – but I hit an issue recently with passing a variable from a child template to a parent. It’s not immediately obvious how to do this, but I found the answer on the Mako Google Groups archive (link here):

Child:

<%inherit file="meta.html"/>

<%def name="vars()">

	<% return (meta.id,) %>

</%def>

Parent:

<% (id,) = self.vars() %>

On a side note, I found out today that two of the Python libraries I’m using, Mako and SQLAlchemy, were coded by the same guy – Michael Bayer. Clever chap – not only are the libraries pretty impressive, but they are both well documented and he regularly contributes to the mailing lists for both projects. And he doesn’t even have a big internet head like some developers – though I tracked his blog down here:

http://techspot.zzzeek.org/

My current CMS project is based on creating templates in the back-end, and then using these to produce ‘inherited’ objects with the same attributes.

I quickly found that it’s surprisingly tricky to grab a template object using SQLAlchemy, and copy it into a similar, but separate, entity. Using the Python ‘copy’ function confuses SQLAlchemy – when you try to save it, it thinks it is merely a representation of the original (template) object.

Here’s how I create separate ‘clones’ from my template objects, defining a function on the object itself:

def clone (self, source, table):

    for c in table.c:

        if not c.name.endswith('id'):

            setattr(self, c.name, getattr(source, c.name))

Here’s a usage example:

template_meta = self.session.query(Meta).filter(and_(Meta.is_template == 1, Meta.id == id)).one()

new_meta = Meta(new_object.id)

new_meta.clone(template_meta, table_meta)

The clone function takes the object’s table as an argument, so that only the basic column values are copied. The table object has an attribute called c – these are the table columns in long form (eg. meta.id, meta.title, etc). Using c.name gives us just the name of the column.

Looping through the source object’s attributes would result in SQLA attributes and any child objects being copied too, which is not what we want.

Notice too that anything ending in ‘id’ is ignored – otherwise we would get the original object’s relationships – again this is not what I want in this situation. The new object should have its own relationships.

my_string.startswith('pre')

The same thing can be achieved in Javascript using the rather powerful search and replace methods.

These methods can either accept strings or regular expressions.  To search for a plain string, use quote marks, for example:

my_string.search('tom');

This will return the index of the first occurence of ‘tom’ in my_string.

To search for a regular expression, use slashes. Regular expressions use special characters to search for particular patterns in strings – we’ll just be using the ‘starts with’ (^)  and ‘ends with’ ($) characters. Therefore, our Python-style startswith and endswith tests looks like this:

my_string.search(/^prefix/) ;

my_string.search(/suffix$/);

Note from Alex Macmillan (honorary proof reader)

While the Python functions return a boolean value depending on the match, the Javascript versions return the index of the matched string. If they are not found, the return value will be -1, not false.