Blogging tool written in Python for Google App Engine
Switch branches/tags
Nothing to show
Pull request Compare This branch is even with nikcub:master.
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.


Version 0.2.1 Saturday, 12th December 2011

A blogging tool built for Google App Engine with the goal of social integration, high performance and flexibility

Blogging rebooted for 2011

NOTE: This is an alpha release for developers

There will eventually be a one-click auto deploy and install, but it isn't there yet


  • Statuses and posts
  • Facebook + twitter integration
  • Support pages
  • Simple and extensible template system
  • Simple default template you can use as a base
  • Plugin system that is easy to use
  • Support for JSON and XML output via the API
  • Static output
  • Auto caching for traffic spikes


The following command will clone the Buckley repo and then deploy it to Google App Engine

$ git clone git:// $ cd Buckley $ -A myappname update .


Get the App Engine SDK:

Clone this code out (or fork and then clone):

$ git clone git://

Create the local datastore files, for eg.

$ mkdir .data
$ touch .data/buckley.datastore

This will help you retain a local copy of all your data. (I actually write posts locally and then deploy)

Start the dev server using the following options:

$ -p 9090 --use_sqlite --disable_static_caching --skip_sdk_update_check .

The options tell the server to use sqlite and to use the local datastore. This means the datastore will be persistent between restarts and you won't lose your data. I recommend you keep a backup of the datastore file.

Or, just deploy and run:

$ update -A yourappengineid .


All the dependancies are bundled. First is Sketch, which is my webapp library for App Engine (the goal of which is to get python appengine apps running on other platforms, and to just provide a nicer layer for web apps that isn't Google webapps and nor is it Django).

Sketch is its own project and is a mix of my own code and third-party code. I use it in all my projects, and the version here is a lighter fork.

Other dependancies, which are included in the vendor directory of Sketch are jinja2, stash (my module for caching) and markdown (for parsing markdown)


Edit the template at ./templates/ or make your own copy in that dir (and update blog.yaml to use it)

To run the app, cd in and run: .

To deploy, use or the GUI that comes with Google App Engine.


Configuration is read from the file that is located in the root directory. The default system-wide configuration is read from sketch That file gives you an idea of what configuration options can be set. The options that are required in are:

Name Type Default Value title string description string frontpage_posts integer 10 plugins dict empty

Syncing remote data to local

You can download your remote server data to your local instance. Make sure you have remote_api enabled.

$ download_data --application=nikcub --url=

And then import

$ upload_data --url=http://localhost:9090/remote_api --auth_domain=localhost:9090 --application=dev~buckleyapp

Enter any username and password. Your app.yaml should have the remote api enabled:

- url: /remote_api
  script: $PYTHON_LIB/google/appengine/ext/remote_api/
  login: admin

This should be before the default route.


Twitter and Facebook integration

You will need to get your own app keys for Twitter and Facebook integration and include them in the config file.


  • Go to
  • Fill in name, description and website URL (put in your blog URL), leaving callback blank
  • Agree to the terms, fill in the captcha (good luck) and hit submit
  • You will need the 'consumer key' and 'consumer secret'

Include them in in the root directory as follow:

	auth_providers = {
	  'twitter': {
	    'key': 'TabZB0TUwlShH4zP8mQQ',
	    'secret': 'yMs8UG9yQp2vM8B2VGEivFgutLk7nYXMiGbjh5T8HiU'


Have a bug? Please create an issue here on GitHub!

Please be as descriptive as you can, including pasting error and exception logs if you have them.


For transparency and insight into our release cycle, releases will be numbered with the follow format:


And constructed with the following guidelines:

  • Breaking backwards compatibility bumps the major
  • New additions without breaking backwards compatibility bumps the minor
  • Bug fixes and misc changes bump the patch

For more information on semantic versioning, please visit


Nik Cubrilovic


Copyright 2011 Nik Cubrilovic.

Licensed under a 2-clause BSD license: