Merge lp:~spud/spud/c-python-binding into lp:spud

[Patrick Farrell]

This branch changes the default Python binding for libspud from python/ctypes to the C api.

The reason for this change is that the C api can do things that python/ctypes can't. In particular, it can access capsules that have been registered through the C api somewhere else. This functionality is exploited with a special case for when this module is ran inside of fluidity's python diagnostics: with a bit of void* shuffling, we can now use this C module to access fluidity's spud tree inside Python.

The first step was to convert the Python wrapper test into something executable. Then, the C module was extended incrementally until it passed all of the tests. So I think that the C module shouldn't make any difference to people who are using the libspud python bindings.

Cian Wilson: while this C module has a very small chunk that is fluidity specific, it is orthogonal to the rest of the code. From your perspective, this commit should (ideally) make no change whatsoever.

The C module was largely written by Nan Mao.

[lp:~spud/spud/c-python-binding]

447. By Patrick Farrell on 2011-08-01

Get rid of a malloc that didn't have a corresponding free

[Cian Wilson (cwilson)]

Where is the libspud module meant to be imported from now?

cwilson@uisce:python$ pwd
/home/cwilson/spud/bzr-repo/c-python-binding/python

cwilson@uisce:python$ echo $PYTHONPATH
/home/cwilson/spud/bzr-repo/c-python-binding/python

cwilson@uisce:python$ python test_libspud.py
Traceback (most recent call last):
  File "test_libspud.py", line 1, in <module>
    import libspud
ImportError: No module named libspud

review: Needs Information

[Patrick Farrell (pefarrell)]

Ah, apologies, I agree it isn't obvious.

The way I was testing it was

python setup.py build
ln -s build/lib*/libspud.so
python test_libspud.py

I didn't add code to install the python bindings because there was no code to install the old ctypes bindings, either. But perhaps I should make a python-spud package too ...

review: Needs Fixing

[Cian Wilson (cwilson)]

A python-spud package would be *very* useful indeed.

Can I ask you to explain the fluidity_api PyCapsule import to me? I can't find anything called fluidity_api in fluidity or in spud so I'm guessing I'm misunderstanding what this is doing. Is this really fluidity specific or could it be used in any model with embedded python? Within fluidity itself does this allow libspud to be used in both python state and the more traditional def val calls?

[Patrick Farrell (pefarrell)]

I will make a python-spud package later, then.

Sure. Capsules are an idea introduced in python 3.1/2.7; there's more information about them in the "What's New" for 2.7. The basic idea is that a capsule contains a void* pointer, and you can register them to store them in a module. It's a mechanism for passing data between different C modules that interact with python; it's a way of passing stuff C -> Python -> different C again.

You can see how I plan to use them in the merge request for get-set-manager:
https://code.launchpad.net/~spud/spud/get-set-manager/+merge/69652

As this whole setup involves changes to libspud, to the python bindings, and to fluidity, I thought I would do them in a logical order. That's why you can't see the corresponding calls for setting PyCapsules in fluidity; it's not in the trunk yet. But you can take a look at
http://bazaar.launchpad.net/~pefarrell/fluidity/diagnostic-python-spud/view/head:/femtools/python_statec.c
to see the other half.

As for its fluidity-specific nature: the whole idea is not specific to fluidity. So we could make it the python-spud convention that you have to register a void* to the manager at "spud_api._spud_manager" instead of "fluidity_api._spud_manager", if you like.

Yes, this means that libspud can be used both in the python state and the def val calls. The fluidity side of it happens in python_init, which is called at the start of the model setup and works for both.

[lp:~spud/spud/c-python-binding]

448. By Patrick Farrell on 2011-08-03

Make a python-spud Debian package.

[Patrick Farrell (pefarrell)]

I've made a Debian package of the Python bindings, python-spud.

[Cian Wilson (cwilson)]

Thanks for the python package. Surprisingly /usr/lib/python2.7/site-packages doesn't appear to be searched automatically by python so I couldn't find it at first but happily all of my tests run with it now I've added it to my PYTHONPATH.

My preference would be to have a more general spud_api for two reasons:
 - my traditional abhorrence of anything fluidity, however small, being in spud, particularly if it would be useful to other programs
 - I have python instances in my code too so this functionality would be useful if it were more generally available

If this is reasonably easily doable then I'd be happier.

[lp:~spud/spud/c-python-binding]

449. By Patrick Farrell on 2011-08-04

Fix the python-spud package; thanks Cian.

450. By Patrick Farrell on 2011-08-04

s/fluidity_api/spud_manager

[Patrick Farrell (pefarrell)]

Excellent, I'm glad that the C python module passes all of your tests.

You pointed out a flaw in the Debian packaging of python-spud; I needed to add an --install-layout=deb to the setup.py install command, and to call the dh_python2 helper during the debian package creation.

I've also changed the "fluidity_api". Now, model code that wants to expose its internal manager should encapsulate it and set it as "spud_manager._spud_manager".

[Cian Wilson (cwilson)]

Um, the package no longer seems to install /usr/lib/python2.7/site-packages/libspud.so. Is this expected and if so where should I be looking now? The only install path that appears in the debian/python-spud directory is usr/share/doc/python-spud/

Thanks for generalising the api. I look forward to using this in my other code.

[Patrick Farrell (pefarrell)]

Yes, site-packages is the wrong place to put it (according to Debian). If you take a look at

dpkg -c ../python-spud_1.1.3_amd64.deb

it tells you the contents of the package:

drwxr-xr-x root/root 0 2011-08-04 18:18 ./
drwxr-xr-x root/root 0 2011-08-04 18:18 ./usr/
drwxr-xr-x root/root 0 2011-08-04 18:18 ./usr/lib/
drwxr-xr-x root/root 0 2011-08-04 18:18 ./usr/lib/python2.6/
drwxr-xr-x root/root 0 2011-08-04 18:18 ./usr/lib/python2.6/dist-packages/
-rw-r--r-- root/root 23120 2011-08-04 18:18 ./usr/lib/python2.6/dist-packages/libspud.so
drwxr-xr-x root/root 0 2011-08-04 18:18 ./usr/lib/pyshared/
drwxr-xr-x root/root 0 2011-08-04 18:18 ./usr/lib/pyshared/python2.6/
drwxr-xr-x root/root 0 2011-08-04 18:18 ./usr/share/
drwxr-xr-x root/root 0 2011-08-04 18:18 ./usr/share/pyshared/
-rw-r--r-- root/root 201 2011-08-04 18:18 ./usr/share/pyshared/libspud-1.1.3.egg-info
drwxr-xr-x root/root 0 2011-08-04 18:18 ./usr/share/doc/
drwxr-xr-x root/root 0 2011-08-04 18:18 ./usr/share/doc/python-spud/
-rw-r--r-- root/root 1656 2011-08-03 11:41 ./usr/share/doc/python-spud/copyright
-rw-r--r-- root/root 2498 2011-07-29 11:33 ./usr/share/doc/python-spud/changelog.gz
lrwxrwxrwx root/root 0 2011-08-04 18:18 ./usr/lib/python2.6/dist-packages/libspud-1.1.3.egg-info -> ../../../share/pyshared/libspud-1.1.3.egg-info
lrwxrwxrwx root/root 0 2011-08-04 18:18 ./usr/lib/pyshared/python2.6/libspud.so -> ../../python2.6/dist-packages/libspud.so

If you install it and ask Python where it's getting it, it replies:

[pef@caoimhe:/data/pfarrell/src]$ python -v -c "import libspud" 2>&1 | grep libspud
dlopen("/usr/lib/python2.6/dist-packages/libspud.so", 2);
import libspud # dynamically loaded from /usr/lib/python2.6/dist-packages/libspud.so

[Cian Wilson (cwilson)]

I get:

cwilson@uisce:c-python-binding$ dpkg -c ../python-spud_1.1.3_amd64.deb
drwxr-xr-x root/root 0 2011-08-04 11:10 ./
drwxr-xr-x root/root 0 2011-08-04 11:10 ./usr/
drwxr-xr-x root/root 0 2011-08-04 11:10 ./usr/share/
drwxr-xr-x root/root 0 2011-08-04 11:10 ./usr/share/doc/
drwxr-xr-x root/root 0 2011-08-04 11:10 ./usr/share/doc/python-spud/
-rw-r--r-- root/root 1656 2011-08-03 09:02 ./usr/share/doc/python-spud/copyright
-rw-r--r-- root/root 2498 2011-08-01 14:56 ./usr/share/doc/python-spud/changelog.gz

and nothing else (I would expect the paths to be slightly different for me as I'm on python 2.7).

Just to be clear, what I've done in the branch is:
./configure && make clean && make && debuild -uc -us
some of which are probably superfluous but I was trying to be thorough.

[lp:~spud/spud/c-python-binding]

451. By Patrick Farrell on 2011-08-04

Some more work on python-spud for natty

452. By Patrick Farrell on 2011-08-04

A grand game of whack-a-mole. This fixes the maverick build. We'll keep iterating until they all work ...

[Patrick Farrell (pefarrell)]

You only need to debuild: it calls the configure and make.

It should be fixed now. There were a few problems with the natty build. I've also made it so that the package now supplies libspud bindings for all supported python versions (2.6 and 2.7 on maverick and natty).

[pef@doodson:/tmp/c-python-binding]$ dpkg -c ../python-spud_1.1.3_amd64.deb
drwxr-xr-x root/root 0 2011-08-04 22:32 ./
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/share/
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/share/pyshared/
-rw-r--r-- root/root 201 2011-08-04 22:32 ./usr/share/pyshared/libspud-1.1.3.egg-info
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/share/doc/
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/share/doc/python-spud/
-rw-r--r-- root/root 2498 2011-08-04 22:04 ./usr/share/doc/python-spud/changelog.gz
-rw-r--r-- root/root 1656 2011-08-04 22:04 ./usr/share/doc/python-spud/copyright
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/lib/
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/lib/pyshared/
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/lib/pyshared/python2.6/
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/lib/pyshared/python2.7/
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/lib/python2.6/
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/lib/python2.6/dist-packages/
-rw-r--r-- root/root 23120 2011-08-04 22:32 ./usr/lib/python2.6/dist-packages/libspud.so
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/lib/python2.7/
drwxr-xr-x root/root 0 2011-08-04 22:32 ./usr/lib/python2.7/dist-packages/
-rw-r--r-- root/root 23120 2011-08-04 22:32 ./usr/lib/python2.7/dist-packages/libspud.so
lrwxrwxrwx root/root 0 2011-08-04 22:32 ./usr/lib/pyshared/python2.6/libspud.so -> ../../python2.6/dist-packages/libspud.so
lrwxrwxrwx root/root 0 2011-08-04 22:32 ./usr/lib/pyshared/python2.7/libspud.so -> ../../python2.7/dist-packages/libspud.so
lrwxrwxrwx root/root 0 2011-08-04 22:32 ./usr/lib/python2.6/dist-packages/libspud-1.1.3.egg-info -> ../../../share/pyshared/libspud-1.1.3.egg-info
lrwxrwxrwx root/root 0 2011-08-04 22:32 ./usr/lib/python2.7/dist-packages/libspud-1.1.3.egg-info -> ../../../share/pyshared/libspud-1.1.3.egg-info

[Cian Wilson (cwilson)]

Thanks Patrick. That works for me now and I've run it manually (and successfully) through my tests again.

Shame about lucid, which is what my buildbot is on (hence the manual bit). Out of curiosity, how were python packages built before dh_python2? I'm guessing upgrading that computer will be easier than backporting.

review: Approve

[Patrick Farrell (pefarrell)]

It could have been dh_python, dh_pycentral or dh_pysupport. dh_python2 supplanted them all. You could try one of those? (I don't have a lucid machine to try it out on.)

In the mean time, I'll merge!

=== modified file 'Makefile.in'
--- Makefile.in	2011-07-11 15:25:35 +0000
+++ Makefile.in	2011-08-04 21:32:37 +0000
@@ -57,7 +57,7 @@
 libspud.la: $(OBJS)
 	./libtool --mode=link --tag=FC $(FC) $(FCFLAGS) -o $(LIB) $(OBJS) $(LIBS) -rpath @prefix@/lib 
 	if test -f .libs/libspud.a; then cp .libs/libspud.a .; fi
-	(if test -f .libs/libspud.so; then cp .libs/libspud.so .; fi) || true
+	(if test -f .libs/libspud.so; then cp .libs/libspud.so ./libspud.so.0; ln -s libspud.so.0 libspud.so; fi) || true
 
 build-diamond:
 	cd diamond; python setup.py build; cd ..
@@ -72,13 +72,14 @@
 doc: 
 	@cd doc; $(MAKE) spud_manual.pdf
 
-install: install-libspud install-spudtools install-diamond
+install: install-libspud install-spudtools install-diamond install-pyspud
 
 install-libspud: libspud.la
 	@INSTALL@ -d $(DESTDIR)@prefix@/lib
 	@INSTALL@ -d $(DESTDIR)@prefix@/include
 	@INSTALL@ libspud.a $(DESTDIR)@prefix@/lib
-	(if test -f libspud.so; then @INSTALL@ libspud.so $(DESTDIR)@prefix@/lib; fi) || true
+	(if test -f libspud.so.0; then @INSTALL@ libspud.so.0 $(DESTDIR)@prefix@/lib; fi) || true
+	(if test -f libspud.so; then cd $(DESTDIR)@prefix@/lib/; ln -s libspud.so.0 libspud.so; cd -; fi) || true
 	@INSTALL@ $(MODS) $(DESTDIR)@prefix@/include
 	@INSTALL@ $(HEADERS) $(DESTDIR)@prefix@/include
 
@@ -93,6 +94,13 @@
 install-diamond:
 	cd diamond;	python setup.py install --prefix=$(DESTDIR)@prefix@; cd ..
 
+install-pyspud:
+ifeq ($(origin DESTDIR),undefined)
+	cd python; python setup.py install --prefix=$(DESTDIR)@prefix@; cd ..
+else
+	cd python; for python in $(shell pyversions -r); do $$python setup.py install --prefix=$(DESTDIR)@prefix@ --install-layout=deb; done; cd ..
+endif
+
 clean:
 	@cd doc; $(MAKE) clean
 	rm -f *.o libspud.a libspud.so *.o *.la *.mod *.lo

=== modified file 'configure'
--- configure	2011-07-11 11:07:06 +0000
+++ configure	2011-08-04 21:32:37 +0000
@@ -21746,7 +21746,7 @@
 
 
 
-ac_config_files="$ac_config_files Makefile src/tests/Makefile examples/Makefile bin/spud-preprocess python/libspud.py diamond/setup.py diamond/diamond/plugins.py diamond/diamond/preprocess.py"
+ac_config_files="$ac_config_files Makefile src/tests/Makefile examples/Makefile bin/spud-preprocess diamond/setup.py diamond/diamond/plugins.py diamond/diamond/preprocess.py"
 
 cat >confcache <<\_ACEOF
 # This file is a shell script that caches the results of configure
@@ -22986,7 +22986,6 @@
     "src/tests/Makefile") CONFIG_FILES="$CONFIG_FILES src/tests/Makefile" ;;
     "examples/Makefile") CONFIG_FILES="$CONFIG_FILES examples/Makefile" ;;
     "bin/spud-preprocess") CONFIG_FILES="$CONFIG_FILES bin/spud-preprocess" ;;
-    "python/libspud.py") CONFIG_FILES="$CONFIG_FILES python/libspud.py" ;;
     "diamond/setup.py") CONFIG_FILES="$CONFIG_FILES diamond/setup.py" ;;
     "diamond/diamond/plugins.py") CONFIG_FILES="$CONFIG_FILES diamond/diamond/plugins.py" ;;
     "diamond/diamond/preprocess.py") CONFIG_FILES="$CONFIG_FILES diamond/diamond/preprocess.py" ;;

=== modified file 'configure.in'
--- configure.in	2011-07-11 11:07:06 +0000
+++ configure.in	2011-08-04 21:32:37 +0000
@@ -306,5 +306,4 @@
 
 AC_OUTPUT(Makefile src/tests/Makefile examples/Makefile
           bin/spud-preprocess
-          python/libspud.py
           diamond/setup.py diamond/diamond/plugins.py diamond/diamond/preprocess.py)

=== modified file 'debian/control'
--- debian/control	2010-04-13 13:51:29 +0000
+++ debian/control	2011-08-04 21:32:37 +0000
@@ -50,3 +50,15 @@
  schema-aware editor such as Diamond. Spudtools contains the schema
  for the spud base language and the spud-preprocess script for
  converting schemas between the compact and xml syntaxes.
+
+Package: python-spud
+Section: python
+Architecture: any
+XB-Python-Version: ${python:Versions}
+Depends: libspud-dev (= ${binary:Version}), ${python:Depends}, ${misc:Depends}
+Description: An automatic options system for scientific models (python interface).
+ Spud is an automatic options system which reads an xml options file 
+ into a dictionary for immediate access from within the model. The xml 
+ file is generated using a spud-compatible RELAX NG schema and a
+ schema-aware editor such as Diamond. This package contains the Python
+ bindings for libspud.

=== modified file 'debian/diamond.copyright'
--- debian/diamond.copyright	2008-09-26 13:42:19 +0000
+++ debian/diamond.copyright	2011-08-04 21:32:37 +0000
@@ -1,4 +1,3 @@
-<<<<<<< .working
 Except as noted below, Diamond is copyright (C) 2007 Imperial College
 London and others. For a full list of contributors see the AUTHORS
 file.

=== added file 'debian/python-spud.copyright'
--- debian/python-spud.copyright	1970-01-01 00:00:00 +0000
+++ debian/python-spud.copyright	2011-08-04 21:32:37 +0000
@@ -0,0 +1,39 @@
+Except as noted below, Spud is copyright (C) 2007 Imperial College
+London and others. For a full list of contributors see the AUTHORS
+file.
+
+Spud is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+On Debian systems, the complete text of the GNU Lesser General Public
+License can be found in the file `/usr/share/common-licenses/LGPL-2.1'.
+
+-----
+
+Tinyxml is copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com)
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
\ No newline at end of file

=== modified file 'debian/rules'
--- debian/rules	2011-07-12 11:24:31 +0000
+++ debian/rules	2011-08-04 21:32:37 +0000
@@ -79,7 +79,10 @@
 	    echo "Failed to locate python egg, was it built correctly?" && exit 1 ; \
 	fi
 
-binary-arch: build-libspud install-libspud install-spudtools
+install-pyspud:
+	$(MAKE) install-pyspud DESTDIR=$(CURDIR)/debian/python-spud
+
+binary-arch: build-libspud install-libspud install-spudtools install-pyspud
 	dh_testdir
 	dh_testroot
 	dh_installchangelogs 
@@ -92,7 +95,7 @@
 #	dh_installemacsen
 #	dh_installpam
 #	dh_installmime
-#	dh_python
+	dh_python2
 #	dh_installinit
 #	dh_installcron
 #	dh_installinfo

=== added file 'python/libspud.c'
--- python/libspud.c	1970-01-01 00:00:00 +0000
+++ python/libspud.c	2011-08-04 21:32:37 +0000
@@ -0,0 +1,831 @@
+#include <Python.h>
+#include <string.h>
+#include "spud.h"
+#include <stdio.h>
+
+#define MAXLENGTH   2048
+
+static PyObject *SpudError;
+static PyObject *SpudTypeError;
+static PyObject *SpudKeyError;
+static PyObject *SpudFileError;
+static PyObject *SpudNewKeyWarning;
+static PyObject *SpudAttrSetFailedWarning;
+static PyObject *SpudShapeError;
+static PyObject *SpudRankError;
+
+void* manager;
+
+static PyObject *
+error_checking(int outcome, char *functionname)
+{
+    char errormessage [MAXLENGTH];
+
+    if (outcome == SPUD_KEY_ERROR){
+        snprintf(errormessage, MAXLENGTH, "Error: The specified option is not present \
+                        in the dictionary in %s", functionname);
+        PyErr_SetString(SpudKeyError, errormessage);
+        return NULL;
+    }
+    if (outcome == SPUD_TYPE_ERROR){
+        snprintf(errormessage, MAXLENGTH, "Error: The specified option has a different \
+                        type from that of the option argument provided in %s", functionname);
+        PyErr_SetString(SpudTypeError, errormessage);
+        return NULL;
+    }
+    if (outcome == SPUD_NEW_KEY_WARNING){
+        snprintf(errormessage, MAXLENGTH, "Warning: The option being inserted is not ]  \
+                        already in the dictionary %s", functionname);
+        PyErr_SetString(SpudNewKeyWarning, errormessage);
+        return NULL;
+    }
+    if (outcome == SPUD_FILE_ERROR){
+        snprintf(errormessage, MAXLENGTH, "Error: The specified options file cannot be  \
+                        read or written to as the routine requires in %s", functionname);
+        PyErr_SetString(SpudFileError, errormessage);
+        return NULL;
+    }
+    if (outcome == SPUD_RANK_ERROR){
+        snprintf(errormessage, MAXLENGTH, "Error: The specified option has a different rank from \
+                      that of the option argument provided %s", functionname);
+        PyErr_SetString(SpudRankError, errormessage);
+        return NULL;
+    }
+    if (outcome == SPUD_SHAPE_ERROR){
+        snprintf(errormessage, MAXLENGTH, "Error: The specified option has a different shape from \
+                      that of the option argument provided in %s", functionname);
+        PyErr_SetString(SpudShapeError, errormessage);
+        return NULL;
+    }
+    if (outcome == SPUD_ATTR_SET_FAILED_WARNING){
+        snprintf(errormessage, MAXLENGTH, "Warning: The option being set as an attribute can not be \
+                      set as an attribute in %s", functionname);
+        PyErr_SetString(SpudAttrSetFailedWarning, errormessage);
+        return NULL;
+    }
+    if (outcome == SPUD_NO_ERROR){
+        Py_RETURN_NONE;
+    }
+
+    PyErr_SetString(SpudError,"Error: error checking failed.");
+    return NULL;
+}
+
+static PyObject *
+libspud_load_options(PyObject *self, PyObject *args)
+{
+    const char *key;
+    int key_len;
+    int outcomeLoadOptions;
+
+    if (!PyArg_ParseTuple(args, "s", &key))
+        return NULL;
+    key_len = strlen(key);
+    outcomeLoadOptions = spud_load_options(key,key_len);
+
+    return error_checking(outcomeLoadOptions, "load options");
+}
+
+static PyObject*
+libspud_print_options(PyObject *self, PyObject *args)
+{
+    spud_print_options();
+
+    Py_RETURN_NONE;
+}
+
+static PyObject *
+libspud_get_number_of_children(PyObject *self, PyObject *args)
+{
+    const char *key;
+    int key_len;
+    int child_count;
+    int outcomeGetNumChildren;
+
+    if (!PyArg_ParseTuple(args, "s", &key))
+        return NULL;
+    key_len = strlen(key);
+    outcomeGetNumChildren = spud_get_number_of_children(key, key_len, &child_count);
+    if (error_checking(outcomeGetNumChildren, "get number of children") == NULL){
+        return NULL;
+    }
+
+    return Py_BuildValue("i", child_count);
+}
+
+static PyObject *
+libspud_get_child_name(PyObject *self, PyObject *args)
+{
+    const char *key;
+    int key_len;
+    int index;
+    char child_name [MAXLENGTH];
+    int i;
+    int outcomeGetChildName;
+
+    for (i = 0; i < MAXLENGTH; i++){
+        child_name[i] = '\0';
+    }
+    if (!PyArg_ParseTuple(args, "si", &key, &index)){
+        return NULL;
+    }
+    key_len = strlen(key);
+    outcomeGetChildName = spud_get_child_name(key, key_len, index, child_name, MAXLENGTH);
+    if (error_checking(outcomeGetChildName, "get child name") == NULL){
+        return NULL;
+    }
+
+    return Py_BuildValue("s", child_name);
+}
+
+static PyObject *
+libspud_option_count(PyObject *self, PyObject *args)
+{
+    const char *key;
+    int key_len;
+    int numoptions;
+
+    if (!PyArg_ParseTuple(args, "s", &key)){
+        return NULL;
+    }
+    key_len = strlen(key);
+    numoptions = spud_option_count(key, key_len);
+
+    return Py_BuildValue("i", numoptions);
+}
+
+static PyObject *
+libspud_have_option(PyObject *self, PyObject *args)
+{
+    const char *key;
+    int key_len;
+    int haveoption;
+
+    if (!PyArg_ParseTuple(args, "s", &key)){
+        return NULL;
+    }
+    key_len = strlen(key);
+    haveoption = spud_have_option(key, key_len);
+
+    if (haveoption == 0){
+        Py_RETURN_FALSE;
+    }
+    else{
+        Py_RETURN_TRUE;
+    }
+}
+
+static PyObject *
+libspud_add_option(PyObject *self, PyObject *args)
+{
+    const char *key;
+    int key_len;
+    int outcomeAddOption;
+
+    if (!PyArg_ParseTuple(args, "s", &key)){
+        return NULL;
+    }
+    key_len = strlen(key);
+    outcomeAddOption = spud_add_option(key, key_len);
+    return error_checking(outcomeAddOption, "add option");
+
+}
+
+static PyObject *
+libspud_get_option_type(PyObject *self, PyObject *args)
+{
+    const char *key;
+    int key_len;
+    int type;
+    int outcomeGetOptionType;
+
+    if (!PyArg_ParseTuple(args, "s", &key)){
+        return NULL;
+    }
+    key_len = strlen(key);
+    outcomeGetOptionType = spud_get_option_type(key, key_len, &type);
+    if (error_checking(outcomeGetOptionType, "get option type") == NULL){
+        return NULL;
+    }
+    if (type == SPUD_DOUBLE){
+        Py_INCREF(&PyFloat_Type);
+        return (PyObject*) &PyFloat_Type;
+    }
+    else if (type == SPUD_INT){
+        Py_INCREF(&PyInt_Type);
+        return (PyObject*) &PyInt_Type;
+    }
+    else if (type == SPUD_NONE){
+        Py_RETURN_NONE;
+    }
+    else if (type == SPUD_STRING){
+        Py_INCREF(&PyString_Type);
+        return (PyObject*) &PyString_Type;
+    }
+
+    PyErr_SetString(SpudError,"Error: Get option type function failed");
+    return NULL;
+}
+
+static PyObject *
+libspud_get_option_rank(PyObject *self, PyObject *args)
+{
+    const char *key;
+    int key_len;
+    int rank;
+    int outcomeGetOptionRank;
+
+    if (!PyArg_ParseTuple(args, "s", &key)){
+        return NULL;
+    }
+    key_len = strlen(key);
+    outcomeGetOptionRank = spud_get_option_rank(key, key_len, &rank);
+    if (error_checking(outcomeGetOptionRank, "get option rank") == NULL){
+        return NULL;
+    }
+
+    return Py_BuildValue("i", rank);
+}
+
+static PyObject *
+libspud_get_option_shape(PyObject *self, PyObject *args)
+{
+    const char *key;
+    int key_len;
+    int shape[2];
+    int outcomeGetOptionShape;
+
+    if (!PyArg_ParseTuple(args, "s", &key)){
+        return NULL;
+    }
+    key_len = strlen(key);
+    outcomeGetOptionShape = spud_get_option_shape(key, key_len, shape);
+    if (error_checking(outcomeGetOptionShape, "get option shape") == NULL){
+        return NULL;
+    }
+
+    return Py_BuildValue("(i,i)", shape[0],shape[1]);
+}
+
+static PyObject*
+spud_get_option_aux_list_ints(const char *key, int key_len, int type, int rank, int *shape)
+{   // this function is for getting option when the option is of type a list of ints
+    int outcomeGetOption;
+    int size = shape[0];
+    int val [size];
+    int j;
+
+    outcomeGetOption = spud_get_option(key, key_len, val);
+    if (error_checking(outcomeGetOption, "get option aux list") == NULL){
+        return NULL;
+    }
+    PyObject* pylist = PyList_New(size);
+    if (pylist == NULL){
+        printf("New list error.");
+        return NULL;
+    }
+    for (j = 0; j < size; j++){
+        PyObject* element = Py_BuildValue("i", val[j]);
+        PyList_SetItem(pylist, j, element);
+    }
+
+    return pylist;
+}
+
+static PyObject*
+spud_get_option_aux_list_doubles(const char *key, int key_len, int type, int rank, int *shape)
+{   // this function is for getting option when the option is of type a list of doubles
+    int outcomeGetOption;
+    int size = shape[0];
+    double val [size];
+    int j;
+
+    outcomeGetOption = spud_get_option(key, key_len, val);
+    if (error_checking(outcomeGetOption, "get option aux list") == NULL){
+        return NULL;
+    }
+    PyObject* pylist = PyList_New(size);
+    if (pylist == NULL){
+        printf("New list error.");
+        return NULL;
+    }
+    for (j = 0; j < size; j++){
+        PyObject* element = Py_BuildValue("f", val[j]);
+        PyList_SetItem(pylist, j, element);
+    }
+
+    return pylist;
+}
+
+static PyObject *
+spud_get_option_aux_scalar_or_string(const char *key, int key_len, int type, int rank, int *shape)
+{   // this function is for getting option when the option is of type a scalar or string
+    int outcomeGetOption;
+
+    if (type == SPUD_DOUBLE){
+        float val;
+        outcomeGetOption = spud_get_option(key, key_len, &val);
+        if (error_checking(outcomeGetOption, "get option aux scalar or string") == NULL){
+            return NULL;
+        }
+        return Py_BuildValue("f", val);
+    }
+    else if (type == SPUD_INT){
+        int val;
+        outcomeGetOption = spud_get_option(key, key_len, &val);
+        if (error_checking(outcomeGetOption, "get option aux scalar or string") == NULL){
+            return NULL;
+        }
+        return Py_BuildValue("i", val);
+    }
+    else if (type == SPUD_STRING) {
+        int size = shape[0];
+        char val[size+1];
+        int i;
+        for (i = 0; i < size+1; i++)
+          val[i] = '\0';
+          
+        outcomeGetOption = spud_get_option(key, key_len, val);
+        if (error_checking(outcomeGetOption, "get option aux scalar or string") == NULL){
+            return NULL;
+        }
+        return Py_BuildValue("s", val);
+    }
+
+    PyErr_SetString(SpudError,"Error: Get option aux scalar failed");
+    return NULL;
+}
+
+static PyObject*
+spud_get_option_aux_tensor_doubles(const char *key, int key_len, int type, int rank, int *shape)
+{   // this function is for getting option when the option is of type a tensor o doubles
+    int outcomeGetOption;
+    int rowsize = shape[0];
+    int colsize = shape[1];
+    int size = rowsize*colsize;
+    double val [size];
+    int m;
+    int n;
+    int counter;
+
+    outcomeGetOption = spud_get_option(key, key_len, val);
+    if (error_checking(outcomeGetOption, "get option aux tensor") == NULL){
+        return NULL;
+    }
+    PyObject* pylist = PyList_New(rowsize);
+    if (pylist == NULL){
+        printf("New list error");
+        return NULL;
+    }
+    counter = 0;
+    for (m = 0; m < rowsize; m++){
+        PyObject* pysublist = PyList_New(colsize);
+        if (pysublist == NULL){
+            printf("New sublist error");
+            return NULL;
+        }
+        for (n = 0; n < colsize; n++){
+            PyObject* element = Py_BuildValue("f", val[counter]);
+            PyList_SetItem(pysublist, n, element);
+            counter++;
+        }
+        PyList_SetItem(pylist, m, pysublist);
+    }
+
+    return pylist;
+}
+
+static PyObject*
+spud_get_option_aux_tensor_ints(const char *key, int key_len, int type, int rank, int *shape)
+{   // this function is for getting option when the option is of type a tensor of ints
+    int outcomeGetOption;
+    int rowsize = shape[0];
+    int colsize = shape[1];
+    int size = rowsize*colsize;
+    int val [size];
+    int m;
+    int n;
+    int counter;
+
+    outcomeGetOption = spud_get_option(key, key_len, val);
+    if (error_checking(outcomeGetOption, "get option aux tensor") == NULL){
+        return NULL;
+    }
+    PyObject* pylist = PyList_New(rowsize);
+    if (pylist == NULL){
+        printf("New list error");
+        return NULL;
+    }
+    counter = 0;
+    for (m = 0; m < rowsize; m++){
+        PyObject* pysublist = PyList_New(colsize);
+        if (pysublist == NULL){
+            printf("New sublist error");
+            return NULL;
+        }
+        for (n = 0; n < colsize; n++){
+            PyObject* element = Py_BuildValue("f", val[counter]);
+            PyList_SetItem(pysublist, n, element);
+            counter++;
+        }
+        PyList_SetItem(pylist, m, pysublist);
+    }
+
+    return pylist;
+}
+
+static PyObject *
+libspud_get_option(PyObject *self, PyObject *args)
+{
+    const char *key;
+    int key_len;
+    int type;
+    int rank = 0;
+    int shape[2];
+    int outcomeGetOptionType;
+    int outcomeGetOptionRank;
+    int outcomeGetOptionShape;
+
+    if(!PyArg_ParseTuple(args, "s", &key)){
+        return NULL;
+    }
+    key_len = strlen(key);
+    outcomeGetOptionRank = spud_get_option_rank(key, key_len, &rank);
+    if (error_checking(outcomeGetOptionRank, "get option") == NULL){
+        return NULL;
+    }
+    outcomeGetOptionType = spud_get_option_type(key, key_len, &type);
+    if (error_checking(outcomeGetOptionType, "get option") == NULL){
+        return NULL;
+    }
+    outcomeGetOptionShape = spud_get_option_shape(key, key_len, shape);
+    if (error_checking(outcomeGetOptionShape, "get option") == NULL){
+        return NULL;
+    }
+    
+    if (rank == -1){ // type error
+        char errormessage [MAXLENGTH];
+        snprintf(errormessage, MAXLENGTH, "Error: The specified option has a different \
+                        type from that of the option argument provided in %s", "get option");
+        PyErr_SetString(SpudTypeError, errormessage);
+        return NULL;
+    }
+    else if (rank == 0){ // scalar
+        return spud_get_option_aux_scalar_or_string(key, key_len, type, rank, shape);
+    }
+    else if (rank == 1){ // list or string
+        if (type == SPUD_INT){  //a list of ints
+            return spud_get_option_aux_list_ints(key, key_len, type, rank, shape);
+        }
+        else if (type == SPUD_DOUBLE){  //a list of doubles
+            return spud_get_option_aux_list_doubles(key, key_len, type, rank, shape);
+        }
+        else if (type == SPUD_STRING){  //string
+            return spud_get_option_aux_scalar_or_string(key, key_len, type, rank, shape);
+        }
+    }
+    else if (rank == 2){ // tensor
+        if (type == SPUD_DOUBLE){  //a tensor of doubles
+            return spud_get_option_aux_tensor_doubles(key, key_len, type, rank, shape);
+        }
+        else if (type == SPUD_INT){  //a tensor of ints
+            return spud_get_option_aux_tensor_ints(key, key_len, type, rank, shape);
+        } 
+    }
+
+    PyErr_SetString(SpudError,"Error: Get option failed.");
+    return NULL;
+}
+static PyObject*
+set_option_aux_list_ints(PyObject *pylist, const char *key, int key_len, int type, int rank, int *shape)
+{   // this function is for setting option when the second argument is of type a list of ints
+    int j;
+    int psize = PyList_Size(pylist);
+    shape[0] = psize;
+    int val[psize] ;
+    int outcomeSetOption;
+    int element;
+
+    for (j = 0; j < psize; j++){
+        element = -1;
+        PyObject* pelement = PyList_GetItem(pylist, j);
+        PyArg_Parse(pelement, "i", &element);
+        val[j] = element;
+    }
+    outcomeSetOption = spud_set_option(key, key_len, val, type, rank, shape);
+    if (error_checking(outcomeSetOption, "set option aux list ints") == NULL){
+        return NULL;
+    }
+    Py_RETURN_NONE;
+}
+
+static PyObject*
+set_option_aux_list_doubles(PyObject *pylist, const char *key, int key_len, int type, int rank, int *shape)
+{   // this function is for setting option when the second argument is of type a list of doubles
+    int j;
+    int psize = PyList_Size(pylist);
+    shape[0] = psize;
+    double val [psize];
+    int outcomeSetOption;
+    double element;
+
+    for (j = 0; j < psize; j++){
+        element = -1.0;
+        PyObject* pelement = PyList_GetItem(pylist, j);
+        PyArg_Parse(pelement, "f", &element);
+        val[j] = element;
+    }
+    outcomeSetOption = spud_set_option(key, key_len, val, type, rank, shape);
+    if (error_checking(outcomeSetOption, "set option aux list ints") == NULL){
+        return NULL;
+    }
+
+    Py_RETURN_NONE;
+}
+
+static PyObject*
+set_option_aux_string(PyObject *pystring, const char *key, int key_len, int type, int rank, int *shape)
+{   // this function is for setting option when the second argument is of type string
+    char *val = PyString_AsString(pystring);
+    int outcomeSetOption = spud_set_option(key, key_len, val, type, rank, shape);
+    return error_checking(outcomeSetOption, "set option aux string");
+}
+
+static PyObject*
+libspud_set_option_attribute(PyObject *self, PyObject *args)
+{
+    const char*key;
+    int key_len;
+    PyObject* firstArg;
+    PyObject* secondArg;
+    const char*val;
+    int val_len;
+    int outcomeSetOption;
+
+    firstArg = PyTuple_GetItem(args, 0);
+    secondArg = PyTuple_GetItem(args, 1);
+    PyArg_Parse(firstArg, "s", &key);
+    key_len = strlen(key);
+    PyArg_Parse(secondArg, "s", &val);
+    val_len = strlen(val);
+    outcomeSetOption = spud_set_option_attribute(key, key_len, val, val_len);
+    return error_checking(outcomeSetOption, "set option attribute");
+}
+
+static PyObject*
+libspud_delete_option(PyObject *self, PyObject *args)
+{
+    const char*key;
+    int key_len;
+    PyObject* firstArg;
+    int outcomeDeleteOption;
+
+    firstArg = PyTuple_GetItem(args, 0);
+    PyArg_Parse(firstArg, "s", &key);
+    key_len = strlen(key);
+    outcomeDeleteOption = spud_delete_option(key, key_len);
+    return error_checking(outcomeDeleteOption, "delete option");
+}
+
+static PyObject*
+set_option_aux_tensor_doubles(PyObject *pylist, const char *key, int key_len, int type, int rank, int *shape)
+{   // this function is for setting option when the second argument is of type a tensor of doubles
+    int i;
+    int j;
+    int counter = 0;
+    int pylistsize = PyList_Size(pylist);
+    shape[0] = pylistsize;
+    
+    int outcomeSetOption;
+    int pysublistsize;
+    PyObject* pysublist = PyList_GetItem(pylist, 0);
+    pysublistsize = PyList_Size(pysublist);
+    int size = pylistsize*pysublistsize;
+    
+    double element;
+    double val [size];
+    
+    for (i = 0; i < pylistsize; i++){
+        PyObject* pysublist = PyList_GetItem(pylist, i);
+        pysublistsize = PyList_Size(pysublist);
+        shape[1] = pysublistsize;
+        for (j = 0; j < pysublistsize; j++){
+            element = -1.0;
+            PyObject* pysublistElement = PyList_GetItem(pysublist, j);
+            PyArg_Parse(pysublistElement, "d", &element);
+            val[counter] = element;
+            counter ++;
+        }
+    }
+
+    outcomeSetOption = spud_set_option(key, key_len, val, type, rank, shape);
+    return error_checking(outcomeSetOption, "set option aux tensor doubles");
+}
+
+static PyObject*
+set_option_aux_tensor_ints(PyObject *pylist, const char *key, int key_len, int type, int rank, int *shape)
+{   // this function is for setting option when the second argument is of type a tensor of ints
+    int i;
+    int j;
+    int counter = 0;
+    int pylistsize = PyList_Size(pylist);
+    shape[0] = pylistsize;
+    int pysublistsize;
+    PyObject* pysublist = PyList_GetItem(pylist, 0);
+    pysublistsize = PyList_Size(pysublist);
+    int size = pylistsize*pysublistsize;
+    int val [size];
+    int outcomeSetOption;
+
+    int element;
+
+    for (i = 0; i < pylistsize; i++){
+        PyObject* pysublist = PyList_GetItem(pylist, i);
+        pysublistsize = PyList_Size(pysublist);
+        shape[1] = pysublistsize;
+        for (j = 0; j < pysublistsize; j++){
+            element = 1;
+            PyObject* pysublistElement = PyList_GetItem(pysublist, j);
+            PyArg_Parse(pysublistElement, "i", &element);
+            val[counter] = element;
+            counter ++;
+        }
+    }
+
+    outcomeSetOption = spud_set_option(key, key_len, val, type, rank, shape);
+    return error_checking(outcomeSetOption, "set option aux tensor doubles");
+}
+
+static PyObject*
+set_option_aux_scalar(PyObject *pyscalar, const char *key, int key_len, int type, int rank, int *shape)
+{   // this function is for setting option when the second argument is of type scalar
+    int outcomeSetOption = SPUD_NO_ERROR;
+
+    if (type == SPUD_DOUBLE){ //scalar is double
+        double val;
+        PyArg_Parse(pyscalar, "f", &val);
+        outcomeSetOption = spud_set_option(key, key_len, &val, type, rank, shape);
+    }
+    else if (type == SPUD_INT){
+        int val;
+        PyArg_Parse(pyscalar, "i", &val);
+        outcomeSetOption = spud_set_option(key, key_len, &val, type, rank, shape);
+    }
+
+    return error_checking(outcomeSetOption, "set option aux scalar");
+}
+
+
+static PyObject*
+libspud_set_option(PyObject *self, PyObject *args)
+{
+    const char *key;
+    int key_len;
+    int type;
+    int rank;
+    int shape[2];
+    int outcomeGetRank;
+    int outcomeGetShape;
+    int outcomeGetType;
+    PyObject* firstArg;
+    PyObject* secondArg;
+
+    firstArg = PyTuple_GetItem(args, 0);
+    secondArg = PyTuple_GetItem(args, 1);
+    PyArg_Parse(firstArg, "s", &key);
+    key_len = strlen(key);
+    outcomeGetType = spud_get_option_type(key, key_len, &type);
+    if (error_checking(outcomeGetType, "set option") == NULL){
+        return NULL;
+    }
+    outcomeGetRank = spud_get_option_rank(key, key_len, &rank);
+    if (error_checking(outcomeGetRank, "set option") == NULL){
+        return NULL;
+    }
+    outcomeGetShape = spud_get_option_shape(key, key_len, shape);
+    if (error_checking(outcomeGetShape, "set option") == NULL){
+        return NULL;
+    }
+    
+    if (rank == 0){ // scalar
+        set_option_aux_scalar(secondArg, key, key_len, type, rank, shape);
+    }
+    else if (rank == 1){ // list or string
+        if (PyString_Check(secondArg)){ // pystring
+            set_option_aux_string(secondArg, key, key_len, type, rank, shape);
+        }
+        else if (type == SPUD_INT) { // list of ints
+            set_option_aux_list_ints(secondArg, key, key_len, type, rank, shape);
+        }    
+        else if (type == SPUD_DOUBLE){ // list of doubles
+            set_option_aux_list_doubles(secondArg, key, key_len, type, rank, shape);
+        } 
+    }
+    else if (rank == 2){ // tensor
+        if (type == SPUD_DOUBLE) { // tensor of doubles
+            set_option_aux_tensor_doubles(secondArg, key, key_len, type, rank, shape);
+        }
+        else if (type == SPUD_INT) { // tensor of ints
+            set_option_aux_tensor_ints(secondArg, key, key_len, type, rank, shape);
+        }
+    }
+
+    Py_RETURN_NONE;
+}
+
+static PyObject*
+libspud_write_options(PyObject *self, PyObject *args)
+{
+    PyObject* firstArg;
+    char *filename;
+    int filename_len;
+    int outcomeWriteOptions;
+
+    firstArg = PyTuple_GetItem(args, 0);
+    PyArg_Parse(firstArg, "s", &filename);
+    filename_len = strlen(filename);
+    outcomeWriteOptions = spud_write_options (filename, filename_len);
+    return error_checking(outcomeWriteOptions, "write options");
+}
+
+static PyMethodDef libspudMethods[] = {
+    {"load_options",  libspud_load_options, METH_VARARGS,
+     "load options from xml file."},
+    {"print_options",  libspud_print_options, METH_VARARGS,
+     "print options from xml file."},
+    {"get_number_of_children",  libspud_get_number_of_children, METH_VARARGS,
+     "get number of children from xml file."},
+    {"get_child_name",  libspud_get_child_name, METH_VARARGS,
+     "get child name from xml file."},
+    {"option_count",  libspud_option_count, METH_VARARGS,
+     "option count from xml file."},
+    {"have_option",  libspud_have_option, METH_VARARGS,
+     "have option from xml file."},
+    {"get_option_type",  libspud_get_option_type, METH_VARARGS,
+     "get option type from xml file."},
+    {"get_option_rank",  libspud_get_option_rank, METH_VARARGS,
+     "get option rank from xml file."},
+    {"get_option_shape",  libspud_get_option_shape, METH_VARARGS,
+     "get option shape from xml file."},
+    {"get_option",  libspud_get_option, METH_VARARGS,
+     "get option from xml file."},
+    {"set_option",  libspud_set_option, METH_VARARGS,
+     "set option from xml file."},
+    {"write_options",  libspud_write_options, METH_VARARGS,
+     "write options from xml file."},
+    {"delete_option",  libspud_delete_option, METH_VARARGS,
+     "delete option from xml file."},
+    {"set_option_attribute",  libspud_set_option_attribute, METH_VARARGS,
+     "set option attribute from xml file."},
+    {"add_option",  libspud_add_option, METH_VARARGS,
+     "add option from xml file."},
+    {NULL, NULL, 0, NULL},
+            /* Sentinel */
+};
+
+PyMODINIT_FUNC
+initlibspud(void)
+{
+    PyObject *m;
+
+    m = Py_InitModule("libspud", libspudMethods);
+    if (m == NULL)
+        return;
+
+    SpudError = PyErr_NewException("Spud.error", NULL, NULL);
+    SpudNewKeyWarning = PyErr_NewException("SpudNewKey.warning", NULL, NULL);
+    SpudKeyError = PyErr_NewException("SpudKey.error", NULL, NULL);
+    SpudTypeError = PyErr_NewException("SpudType.error", NULL, NULL);
+    SpudFileError = PyErr_NewException("SpudFile.warning", NULL, NULL);
+    SpudAttrSetFailedWarning = PyErr_NewException("SpudAttrSetFailed.warning", NULL, NULL);
+    SpudShapeError = PyErr_NewException("SpudShape.error", NULL, NULL);
+    SpudRankError = PyErr_NewException("SpudRank.error", NULL, NULL);
+
+    Py_INCREF(SpudError);
+    Py_INCREF(SpudNewKeyWarning);
+    Py_INCREF(SpudKeyError);
+    Py_INCREF(SpudTypeError);
+    Py_INCREF(SpudFileError);
+    Py_INCREF(SpudRankError);
+    Py_INCREF(SpudShapeError);
+    Py_INCREF(SpudAttrSetFailedWarning);
+
+    PyModule_AddObject(m, "SpudError", SpudError);
+    PyModule_AddObject(m, "SpudNewKeyWarning", SpudNewKeyWarning);
+    PyModule_AddObject(m, "SpudKeyError", SpudKeyError);
+    PyModule_AddObject(m, "SpudTypeError", SpudTypeError);
+    PyModule_AddObject(m, "SpudFileError", SpudFileError);
+    PyModule_AddObject(m, "SpudAttrSetFailedWarning", SpudAttrSetFailedWarning);
+    PyModule_AddObject(m, "SpudShapeError", SpudShapeError);
+    PyModule_AddObject(m, "SpudRankError", SpudRankError);
+
+
+#if PY_MINOR_VERSION > 6
+    manager = PyCapsule_Import("spud_manager._spud_manager", 0);
+    if (manager != NULL) spud_set_manager(manager);
+    else PyErr_Clear();
+#endif
+
+}
+
+

=== renamed file 'python/libspud.py.in' => 'python/libspud.py.ctypes'
=== added file 'python/setup.py'
--- python/setup.py	1970-01-01 00:00:00 +0000
+++ python/setup.py	2011-08-04 21:32:37 +0000
@@ -0,0 +1,9 @@
+from distutils.core import setup, Extension
+import os.path
+
+module1 = Extension('libspud', sources = ['libspud.c'], libraries=["spud"], library_dirs=[os.path.abspath("..")], include_dirs=[os.path.abspath("../include")])
+
+setup (name = 'libspud',
+       version = '1.1.3',
+       description = 'Python bindings for libspud',
+       ext_modules = [module1])

=== renamed file 'python/test_ctypes.py' => 'python/test_libspud.py'
--- python/test_ctypes.py	2011-07-19 05:47:49 +0000
+++ python/test_libspud.py	2011-08-04 21:32:37 +0000
@@ -1,78 +1,87 @@
 import libspud
-print libspud.__file__
 
 libspud.load_options('test.flml')
 
-libspud.print_options()
-
-print libspud.get_number_of_children('/geometry')
-print libspud.get_child_name('geometry', 0)
-
-print libspud.option_count('/problem_type')
-print libspud.have_option('/problem_type')
-
-print libspud.get_option_type('/geometry/dimension')
-print libspud.get_option_type('/problem_type')
-
-print libspud.get_option_rank('/geometry/dimension')
-print libspud.get_option_rank('/physical_parameters/gravity/vector_field::GravityDirection/prescribed/value/constant')
-
-print libspud.get_option_shape('/geometry/dimension')
-print libspud.get_option_shape('/problem_type')
-
-print libspud.get_option('/problem_type')
-print libspud.get_option('/geometry/dimension')
+#libspud.print_options()
+
+assert libspud.get_number_of_children('/geometry') == 5
+assert libspud.get_child_name('geometry', 0) == "dimension"
+
+assert libspud.option_count('/problem_type') == 1
+assert libspud.have_option('/problem_type')
+
+assert libspud.get_option_type('/geometry/dimension') is int
+assert libspud.get_option_type('/problem_type') is str
+
+assert libspud.get_option_rank('/geometry/dimension') == 0
+assert libspud.get_option_rank('/physical_parameters/gravity/vector_field::GravityDirection/prescribed/value/constant') == 1
+
+assert libspud.get_option_shape('/geometry/dimension') == (-1, -1)
+assert libspud.get_option_shape('/problem_type')[0] > 1
+assert libspud.get_option_shape('/problem_type')[1] == -1
+
+assert libspud.get_option('/problem_type') == "multimaterial"
+assert libspud.get_option('/geometry/dimension') == 2
 libspud.set_option('/geometry/dimension', 3)
-print libspud.get_option('/geometry/dimension')
+
+
+assert libspud.get_option('/geometry/dimension') == 3
 
 list_path = '/material_phase::Material1/scalar_field::MaterialVolumeFraction/prognostic/boundary_conditions::LetNoOneLeave/surface_ids'
-print libspud.get_option_shape(list_path)
-print libspud.get_option_rank(list_path)
-print libspud.get_option(list_path)
-assert(libspud.get_option(list_path)==[7,8,9,10])
-libspud.set_option(list_path, [11,12,13,14])
-print libspud.get_option_shape(list_path)
-print libspud.get_option_rank(list_path)
-print libspud.get_option(list_path)
-assert(libspud.get_option(list_path)==[11,12,13,14])
+assert libspud.get_option_shape(list_path) == (4, -1)
+assert libspud.get_option_rank(list_path) == 1
+assert libspud.get_option(list_path) == [7, 8, 9, 10]
+
+libspud.set_option(list_path, [11, 12, 13, 14, 15])
+assert libspud.get_option_shape(list_path) == (5, -1)
+assert libspud.get_option_rank(list_path) == 1
+assert libspud.get_option(list_path)==[11, 12, 13, 14, 15]
 
 tensor_path = '/material_phase::Material1/tensor_field::DummyTensor/prescribed/value::WholeMesh/anisotropic_asymmetric/constant'
-print libspud.get_option_shape(tensor_path)
-print libspud.get_option_rank(tensor_path)
-print libspud.get_option(tensor_path)
-assert(libspud.get_option(tensor_path)==[[1.0,2.0],[3.0,4.0]])
-libspud.set_option(tensor_path, [[5.0,6.0],[7.0,8.0]])
-print libspud.get_option_shape(tensor_path)
-print libspud.get_option_rank(tensor_path)
-print libspud.get_option(tensor_path)
-assert(libspud.get_option(tensor_path)==[[5.0,6.0],[7.0,8.0]])
+assert libspud.get_option_shape(tensor_path) == (2, 2)
+assert libspud.get_option_rank(tensor_path) == 2
+assert libspud.get_option(tensor_path)==[[1.0,2.0],[3.0,4.0]]
+
+libspud.set_option(tensor_path, [[5.0,6.0,2.0],[7.0,8.0,1.0]])
+#assert libspud.get_option_shape(tensor_path) == (3,3)
+assert libspud.get_option_rank(tensor_path) == 2
+
+assert(libspud.get_option(tensor_path)==[[5.0, 6.0, 2.0],[7.0, 8.0, 1.0]])
 
 try:
   libspud.add_option('/foo')
+  assert False
 except libspud.SpudNewKeyWarning, e:
-  print "caught libspud.SpudNewKeyWarning: "+e.message
-print libspud.option_count('/foo')
+  pass
+
+assert libspud.option_count('/foo') == 1
 
 libspud.set_option('/problem_type', 'helloworld')
-print libspud.get_option('/problem_type')
+assert libspud.get_option('/problem_type') == "helloworld"
 
 try:
   libspud.set_option_attribute('/foo/bar', 'foobar')
+  assert False
 except libspud.SpudNewKeyWarning, e:
-  print "caught libspud.SpudNewKeyWarning: "+e.message
-print libspud.get_option('/foo/bar')
+  pass
+
+assert libspud.get_option('/foo/bar') == "foobar"
   
 libspud.delete_option('/foo')
-print libspud.option_count('/foo')
+assert libspud.option_count('/foo') == 0
 
 try:
   libspud.get_option('/foo')
+  assert False
 except libspud.SpudKeyError, e:
-  print "caught libspud.SpudKeyError: "+e.message
+  pass
 
 try:
   libspud.get_option('/geometry')
+  assert False
 except libspud.SpudTypeError, e:
-  print "caught libspud.SpudTypeError: "+e.message
+  pass
 
 libspud.write_options('test_out.flml')
+
+print "All tests passed!"