Lots, mainly Python bindings.

7 files changed, 2191 insertions, 8 deletions

diff --git a/python/Makefile.am b/python/Makefile.am
index 509e87ca..b2cf3b34 100644
--- a/python/Makefile.am
+++ b/python/Makefile.am
@@ -15,10 +15,27 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-EXTRA_DIST = README-python-bindings
+EXTRA_DIST = \
+	guestfs.py \
+	guestfs-py.c \
+	t/*.py
 
 CLEANFILES = *~
 
 if HAVE_PYTHON
 
+pythondir = $(PYTHON_SITE_PACKAGES)
+
+python_LTLIBRARIES = libguestfsmod.la
+
+libguestfsmod_la_SOURCES = guestfs-py.c
+libguestfsmod_la_CFLAGS = -Wall -I$(PYTHON_INCLUDEDIR) -I$(top_builddir)/src
+libguestfsmod_la_LIBADD = $(top_builddir)/src/libguestfs.la
+
+TESTS_ENVIRONMENT = \
+	LIBGUESTFS_PATH=$(abs_top_builddir) \
+	PYTHONPATH=$(abs_top_builddir)/python:$(abs_top_builddir)/python/.libs \
+	$(PYTHON)
+TESTS = t/005-import.py t/010-launch.py t/050-lvcreate.py
+
 endif
\ No newline at end of file
diff --git a/python/README-python-bindings b/python/README-python-bindings
deleted file mode 100644
index 4c5aa382..00000000
--- a/python/README-python-bindings
+++ /dev/null
@@ -1,7 +0,0 @@
-There are no Python bindings right now.
-
-Know Python?  Why not contribute some!
-
-You will need to autogenerate them by adding the appropriate code
-snippets to src/generator.ml.  For inspiration, I suggest looking at
-how the OCaml and Perl bindings were done.
diff --git a/python/guestfs-py.c b/python/guestfs-py.c
new file mode 100644
index 00000000..9d2738c8
--- /dev/null
+++ b/python/guestfs-py.c
@@ -0,0 +1,1883 @@
+/* libguestfs generated file
+ * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
+ * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
+ *
+ * Copyright (C) 2009 Red Hat Inc.
+ *
+ * This library 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 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.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include <Python.h>
+
+#include "guestfs.h"
+
+typedef struct {
+  PyObject_HEAD
+  guestfs_h *g;
+} Pyguestfs_Object;
+
+static guestfs_h *
+get_handle (PyObject *obj)
+{
+  assert (obj);
+  assert (obj != Py_None);
+  return ((Pyguestfs_Object *) obj)->g;
+}
+
+static PyObject *
+put_handle (guestfs_h *g)
+{
+  assert (g);
+  return
+    PyCObject_FromVoidPtrAndDesc ((void *) g, (char *) "guestfs_h", NULL);
+}
+
+/* This list should be freed (but not the strings) after use. */
+static const char **
+get_string_list (PyObject *obj)
+{
+  int i, len;
+  const char **r;
+
+  assert (obj);
+
+  if (!PyList_Check (obj)) {
+    PyErr_SetString (PyExc_RuntimeError, "expecting a list parameter");
+    return NULL;
+  }
+
+  len = PyList_Size (obj);
+  r = malloc (sizeof (char *) * (len+1));
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, "get_string_list: out of memory");
+    return NULL;
+  }
+
+  for (i = 0; i < len; ++i)
+    r[i] = PyString_AsString (PyList_GetItem (obj, i));
+  r[len] = NULL;
+
+  return r;
+}
+
+static PyObject *
+put_string_list (char * const * const argv)
+{
+  PyObject *list;
+  int argc, i;
+
+  for (argc = 0; argv[argc] != NULL; ++argc)
+    ;
+
+  list = PyList_New (argc);
+  for (i = 0; i < argc; ++i)
+    PyList_SetItem (list, i, PyString_FromString (argv[i]));
+
+  return list;
+}
+
+static void
+free_strings (char **argv)
+{
+  int argc;
+
+  for (argc = 0; argv[argc] != NULL; ++argc)
+    free (argv[argc]);
+  free (argv);
+}
+
+static PyObject *
+py_guestfs_create (PyObject *self, PyObject *args)
+{
+  guestfs_h *g;
+
+  g = guestfs_create ();
+  if (g == NULL) {
+    PyErr_SetString (PyExc_RuntimeError,
+                     "guestfs.create: failed to allocate handle");
+    return NULL;
+  }
+  guestfs_set_error_handler (g, NULL, NULL);
+  return put_handle (g);
+}
+
+static PyObject *
+py_guestfs_close (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_close", &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  guestfs_close (g);
+
+  Py_INCREF (Py_None);
+  return Py_None;
+}
+
+static PyObject *
+put_lvm_pv (struct guestfs_lvm_pv *pv)
+{
+  PyObject *dict;
+
+  dict = PyDict_New ();
+  PyDict_SetItemString (dict, "pv_name",
+                        PyString_FromString (pv->pv_name));
+  PyDict_SetItemString (dict, "pv_uuid",
+                        PyString_FromStringAndSize (pv->pv_uuid, 32));
+  PyDict_SetItemString (dict, "pv_fmt",
+                        PyString_FromString (pv->pv_fmt));
+  PyDict_SetItemString (dict, "pv_size",
+                        PyLong_FromUnsignedLongLong (pv->pv_size));
+  PyDict_SetItemString (dict, "dev_size",
+                        PyLong_FromUnsignedLongLong (pv->dev_size));
+  PyDict_SetItemString (dict, "pv_free",
+                        PyLong_FromUnsignedLongLong (pv->pv_free));
+  PyDict_SetItemString (dict, "pv_used",
+                        PyLong_FromUnsignedLongLong (pv->pv_used));
+  PyDict_SetItemString (dict, "pv_attr",
+                        PyString_FromString (pv->pv_attr));
+  PyDict_SetItemString (dict, "pv_pe_count",
+                        PyLong_FromLongLong (pv->pv_pe_count));
+  PyDict_SetItemString (dict, "pv_pe_alloc_count",
+                        PyLong_FromLongLong (pv->pv_pe_alloc_count));
+  PyDict_SetItemString (dict, "pv_tags",
+                        PyString_FromString (pv->pv_tags));
+  PyDict_SetItemString (dict, "pe_start",
+                        PyLong_FromUnsignedLongLong (pv->pe_start));
+  PyDict_SetItemString (dict, "pv_mda_count",
+                        PyLong_FromLongLong (pv->pv_mda_count));
+  PyDict_SetItemString (dict, "pv_mda_free",
+                        PyLong_FromUnsignedLongLong (pv->pv_mda_free));
+  return dict;
+};
+
+static PyObject *
+put_lvm_pv_list (struct guestfs_lvm_pv_list *pvs)
+{
+  PyObject *list;
+  int i;
+
+  list = PyList_New (pvs->len);
+  for (i = 0; i < pvs->len; ++i)
+    PyList_SetItem (list, i, put_lvm_pv (&pvs->val[i]));
+  return list;
+};
+
+static PyObject *
+put_lvm_vg (struct guestfs_lvm_vg *vg)
+{
+  PyObject *dict;
+
+  dict = PyDict_New ();
+  PyDict_SetItemString (dict, "vg_name",
+                        PyString_FromString (vg->vg_name));
+  PyDict_SetItemString (dict, "vg_uuid",
+                        PyString_FromStringAndSize (vg->vg_uuid, 32));
+  PyDict_SetItemString (dict, "vg_fmt",
+                        PyString_FromString (vg->vg_fmt));
+  PyDict_SetItemString (dict, "vg_attr",
+                        PyString_FromString (vg->vg_attr));
+  PyDict_SetItemString (dict, "vg_size",
+                        PyLong_FromUnsignedLongLong (vg->vg_size));
+  PyDict_SetItemString (dict, "vg_free",
+                        PyLong_FromUnsignedLongLong (vg->vg_free));
+  PyDict_SetItemString (dict, "vg_sysid",
+                        PyString_FromString (vg->vg_sysid));
+  PyDict_SetItemString (dict, "vg_extent_size",
+                        PyLong_FromUnsignedLongLong (vg->vg_extent_size));
+  PyDict_SetItemString (dict, "vg_extent_count",
+                        PyLong_FromLongLong (vg->vg_extent_count));
+  PyDict_SetItemString (dict, "vg_free_count",
+                        PyLong_FromLongLong (vg->vg_free_count));
+  PyDict_SetItemString (dict, "max_lv",
+                        PyLong_FromLongLong (vg->max_lv));
+  PyDict_SetItemString (dict, "max_pv",
+                        PyLong_FromLongLong (vg->max_pv));
+  PyDict_SetItemString (dict, "pv_count",
+                        PyLong_FromLongLong (vg->pv_count));
+  PyDict_SetItemString (dict, "lv_count",
+                        PyLong_FromLongLong (vg->lv_count));
+  PyDict_SetItemString (dict, "snap_count",
+                        PyLong_FromLongLong (vg->snap_count));
+  PyDict_SetItemString (dict, "vg_seqno",
+                        PyLong_FromLongLong (vg->vg_seqno));
+  PyDict_SetItemString (dict, "vg_tags",
+                        PyString_FromString (vg->vg_tags));
+  PyDict_SetItemString (dict, "vg_mda_count",
+                        PyLong_FromLongLong (vg->vg_mda_count));
+  PyDict_SetItemString (dict, "vg_mda_free",
+                        PyLong_FromUnsignedLongLong (vg->vg_mda_free));
+  return dict;
+};
+
+static PyObject *
+put_lvm_vg_list (struct guestfs_lvm_vg_list *vgs)
+{
+  PyObject *list;
+  int i;
+
+  list = PyList_New (vgs->len);
+  for (i = 0; i < vgs->len; ++i)
+    PyList_SetItem (list, i, put_lvm_vg (&vgs->val[i]));
+  return list;
+};
+
+static PyObject *
+put_lvm_lv (struct guestfs_lvm_lv *lv)
+{
+  PyObject *dict;
+
+  dict = PyDict_New ();
+  PyDict_SetItemString (dict, "lv_name",
+                        PyString_FromString (lv->lv_name));
+  PyDict_SetItemString (dict, "lv_uuid",
+                        PyString_FromStringAndSize (lv->lv_uuid, 32));
+  PyDict_SetItemString (dict, "lv_attr",
+                        PyString_FromString (lv->lv_attr));
+  PyDict_SetItemString (dict, "lv_major",
+                        PyLong_FromLongLong (lv->lv_major));
+  PyDict_SetItemString (dict, "lv_minor",
+                        PyLong_FromLongLong (lv->lv_minor));
+  PyDict_SetItemString (dict, "lv_kernel_major",
+                        PyLong_FromLongLong (lv->lv_kernel_major));
+  PyDict_SetItemString (dict, "lv_kernel_minor",
+                        PyLong_FromLongLong (lv->lv_kernel_minor));
+  PyDict_SetItemString (dict, "lv_size",
+                        PyLong_FromUnsignedLongLong (lv->lv_size));
+  PyDict_SetItemString (dict, "seg_count",
+                        PyLong_FromLongLong (lv->seg_count));
+  PyDict_SetItemString (dict, "origin",
+                        PyString_FromString (lv->origin));
+  if (lv->snap_percent >= 0)
+    PyDict_SetItemString (dict, "snap_percent",
+                          PyFloat_FromDouble ((double) lv->snap_percent));
+  else {
+    Py_INCREF (Py_None);
+    PyDict_SetItemString (dict, "snap_percent", Py_None);  }
+  if (lv->copy_percent >= 0)
+    PyDict_SetItemString (dict, "copy_percent",
+                          PyFloat_FromDouble ((double) lv->copy_percent));
+  else {
+    Py_INCREF (Py_None);
+    PyDict_SetItemString (dict, "copy_percent", Py_None);  }
+  PyDict_SetItemString (dict, "move_pv",
+                        PyString_FromString (lv->move_pv));
+  PyDict_SetItemString (dict, "lv_tags",
+                        PyString_FromString (lv->lv_tags));
+  PyDict_SetItemString (dict, "mirror_log",
+                        PyString_FromString (lv->mirror_log));
+  PyDict_SetItemString (dict, "modules",
+                        PyString_FromString (lv->modules));
+  return dict;
+};
+
+static PyObject *
+put_lvm_lv_list (struct guestfs_lvm_lv_list *lvs)
+{
+  PyObject *list;
+  int i;
+
+  list = PyList_New (lvs->len);
+  for (i = 0; i < lvs->len; ++i)
+    PyList_SetItem (list, i, put_lvm_lv (&lvs->val[i]));
+  return list;
+};
+
+static PyObject *
+py_guestfs_launch (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_launch",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_launch (g);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_wait_ready (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_wait_ready",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_wait_ready (g);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_kill_subprocess (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_kill_subprocess",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_kill_subprocess (g);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_add_drive (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *filename;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive",
+                         &py_g, &filename))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_add_drive (g, filename);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_add_cdrom (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *filename;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_cdrom",
+                         &py_g, &filename))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_add_cdrom (g, filename);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_config (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *qemuparam;
+  const char *qemuvalue;
+
+  if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_config",
+                         &py_g, &qemuparam, &qemuvalue))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_config (g, qemuparam, qemuvalue);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_set_path (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_set_path (g, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_get_path (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  const char *r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_get_path (g);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = PyString_FromString (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_set_autosync (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  int autosync;
+
+  if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync",
+                         &py_g, &autosync))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_set_autosync (g, autosync);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_get_autosync (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_get_autosync (g);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = PyInt_FromLong ((long) r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_set_verbose (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  int verbose;
+
+  if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose",
+                         &py_g, &verbose))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_set_verbose (g, verbose);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_get_verbose (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_verbose",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_get_verbose (g);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = PyInt_FromLong ((long) r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_mount (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *device;
+  const char *mountpoint;
+
+  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
+                         &py_g, &device, &mountpoint))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_mount (g, device, mountpoint);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_sync (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_sync (g);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_touch (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_touch (g, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_cat (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char *r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_cat (g, path);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = PyString_FromString (r);
+  free (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_ll (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char *r;
+  const char *directory;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll",
+                         &py_g, &directory))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_ll (g, directory);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = PyString_FromString (r);
+  free (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_ls (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char **r;
+  const char *directory;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
+                         &py_g, &directory))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_ls (g, directory);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_string_list (r);
+  free_strings (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_list_devices (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char **r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_list_devices (g);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_string_list (r);
+  free_strings (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_list_partitions (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char **r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_list_partitions (g);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_string_list (r);
+  free_strings (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_pvs (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char **r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_pvs (g);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_string_list (r);
+  free_strings (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_vgs (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char **r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_vgs (g);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_string_list (r);
+  free_strings (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_lvs (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char **r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_lvs (g);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_string_list (r);
+  free_strings (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_pvs_full (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  struct guestfs_lvm_pv_list *r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_pvs_full (g);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_lvm_pv_list (r);
+  guestfs_free_lvm_pv_list (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_vgs_full (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  struct guestfs_lvm_vg_list *r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_vgs_full (g);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_lvm_vg_list (r);
+  guestfs_free_lvm_vg_list (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_lvs_full (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  struct guestfs_lvm_lv_list *r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_lvs_full (g);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_lvm_lv_list (r);
+  guestfs_free_lvm_lv_list (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_read_lines (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char **r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_read_lines (g, path);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_string_list (r);
+  free_strings (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_init (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *root;
+  int flags;
+
+  if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
+                         &py_g, &root, &flags))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_init (g, root, flags);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_close (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_close (g);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_defvar (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *name;
+  const char *expr;
+
+  if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
+                         &py_g, &name, &expr))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_defvar (g, name, expr);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = PyInt_FromLong ((long) r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_defnode (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  struct guestfs_int_bool *r;
+  const char *name;
+  const char *expr;
+  const char *val;
+
+  if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
+                         &py_g, &name, &expr, &val))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_defnode (g, name, expr, val);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = PyTuple_New (2);
+  PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
+  PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
+  guestfs_free_int_bool (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_get (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char *r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_get (g, path);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = PyString_FromString (r);
+  free (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_set (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+  const char *val;
+
+  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
+                         &py_g, &path, &val))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_set (g, path, val);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_insert (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+  const char *label;
+  int before;
+
+  if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
+                         &py_g, &path, &label, &before))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_insert (g, path, label, before);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_rm (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_rm (g, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = PyInt_FromLong ((long) r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_mv (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *src;
+  const char *dest;
+
+  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
+                         &py_g, &src, &dest))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_mv (g, src, dest);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_match (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char **r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_match (g, path);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_string_list (r);
+  free_strings (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_save (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_save (g);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_load (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_load (g);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_aug_ls (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char **r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_aug_ls (g, path);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_string_list (r);
+  free_strings (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_rm (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_rm (g, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_rmdir (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_rmdir (g, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_rm_rf (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_rm_rf (g, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_mkdir (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_mkdir (g, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_mkdir_p (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_mkdir_p (g, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_chmod (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  int mode;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
+                         &py_g, &mode, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_chmod (g, mode, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_chown (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  int owner;
+  int group;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
+                         &py_g, &owner, &group, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_chown (g, owner, group, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_exists (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_exists (g, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = PyInt_FromLong ((long) r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_is_file (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_is_file (g, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = PyInt_FromLong ((long) r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_is_dir (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_dir",
+                         &py_g, &path))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_is_dir (g, path);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = PyInt_FromLong ((long) r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_pvcreate (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *device;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
+                         &py_g, &device))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_pvcreate (g, device);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_vgcreate (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *volgroup;
+  PyObject *py_physvols;
+  const char **physvols;
+
+  if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
+                         &py_g, &volgroup, &py_physvols))
+    return NULL;
+  g = get_handle (py_g);
+  physvols = get_string_list (py_physvols);
+  if (!physvols) return NULL;
+
+  r = guestfs_vgcreate (g, volgroup, physvols);
+  free (physvols);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_lvcreate (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *logvol;
+  const char *volgroup;
+  int mbytes;
+
+  if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
+                         &py_g, &logvol, &volgroup, &mbytes))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_mkfs (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *fstype;
+  const char *device;
+
+  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
+                         &py_g, &fstype, &device))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_mkfs (g, fstype, device);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_sfdisk (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *device;
+  int cyls;
+  int heads;
+  int sectors;
+  PyObject *py_lines;
+  const char **lines;
+
+  if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
+                         &py_g, &device, &cyls, &heads, &sectors, &py_lines))
+    return NULL;
+  g = get_handle (py_g);
+  lines = get_string_list (py_lines);
+  if (!lines) return NULL;
+
+  r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
+  free (lines);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_write_file (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *path;
+  const char *content;
+  int size;
+
+  if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
+                         &py_g, &path, &content, &size))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_write_file (g, path, content, size);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_umount (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+  const char *pathordevice;
+
+  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
+                         &py_g, &pathordevice))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_umount (g, pathordevice);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_mounts (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  char **r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_mounts (g);
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  py_r = put_string_list (r);
+  free_strings (r);
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_umount_all (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_umount_all (g);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyObject *
+py_guestfs_lvm_remove_all (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+  PyObject *py_r;
+  int r;
+
+  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all",
+                         &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  r = guestfs_lvm_remove_all (g);
+  if (r == -1) {
+    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
+    return NULL;
+  }
+
+  Py_INCREF (Py_None);
+  py_r = Py_None;
+  return py_r;
+}
+
+static PyMethodDef methods[] = {
+  { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
+  { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
+  { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
+  { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
+  { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
+  { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
+  { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
+  { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
+  { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
+  { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
+  { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
+  { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
+  { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
+  { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
+  { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
+  { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
+  { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
+  { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
+  { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
+  { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
+  { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
+  { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
+  { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
+  { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
+  { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
+  { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
+  { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
+  { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
+  { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
+  { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
+  { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
+  { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
+  { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
+  { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
+  { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
+  { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
+  { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
+  { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
+  { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
+  { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
+  { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
+  { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
+  { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
+  { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
+  { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
+  { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
+  { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
+  { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
+  { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
+  { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
+  { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
+  { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
+  { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
+  { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
+  { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
+  { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
+  { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
+  { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
+  { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
+  { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
+  { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
+  { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
+  { NULL, NULL, 0, NULL }
+};
+
+void
+initlibguestfsmod (void)
+{
+  static int initialized = 0;
+
+  if (initialized) return;
+  Py_InitModule ((char *) "libguestfsmod", methods);
+  initialized = 1;
+}
diff --git a/python/guestfs.py b/python/guestfs.py
new file mode 100644
index 00000000..fc57d8de
--- /dev/null
+++ b/python/guestfs.py
@@ -0,0 +1,209 @@
+# libguestfs generated file
+# WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
+# ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
+#
+# Copyright (C) 2009 Red Hat Inc.
+#
+# This library 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 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.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+import libguestfsmod
+
+class guestfs:
+    def __init__ (self):
+        self._o = libguestfsmod.create ()
+
+    def __del__ (self):
+        libguestfsmod.close (self._o)
+
+    def launch (self):
+        return libguestfsmod.launch (self._o)
+
+    def wait_ready (self):
+        return libguestfsmod.wait_ready (self._o)
+
+    def kill_subprocess (self):
+        return libguestfsmod.kill_subprocess (self._o)
+
+    def add_drive (self, filename):
+        return libguestfsmod.add_drive (self._o, filename)
+
+    def add_cdrom (self, filename):
+        return libguestfsmod.add_cdrom (self._o, filename)
+
+    def config (self, qemuparam, qemuvalue):
+        return libguestfsmod.config (self._o, qemuparam, qemuvalue)
+
+    def set_path (self, path):
+        return libguestfsmod.set_path (self._o, path)
+
+    def get_path (self):
+        return libguestfsmod.get_path (self._o)
+
+    def set_autosync (self, autosync):
+        return libguestfsmod.set_autosync (self._o, autosync)
+
+    def get_autosync (self):
+        return libguestfsmod.get_autosync (self._o)
+
+    def set_verbose (self, verbose):
+        return libguestfsmod.set_verbose (self._o, verbose)
+
+    def get_verbose (self):
+        return libguestfsmod.get_verbose (self._o)
+
+    def mount (self, device, mountpoint):
+        return libguestfsmod.mount (self._o, device, mountpoint)
+
+    def sync (self):
+        return libguestfsmod.sync (self._o)
+
+    def touch (self, path):
+        return libguestfsmod.touch (self._o, path)
+
+    def cat (self, path):
+        return libguestfsmod.cat (self._o, path)
+
+    def ll (self, directory):
+        return libguestfsmod.ll (self._o, directory)
+
+    def ls (self, directory):
+        return libguestfsmod.ls (self._o, directory)
+
+    def list_devices (self):
+        return libguestfsmod.list_devices (self._o)
+
+    def list_partitions (self):
+        return libguestfsmod.list_partitions (self._o)
+
+    def pvs (self):
+        return libguestfsmod.pvs (self._o)
+
+    def vgs (self):
+        return libguestfsmod.vgs (self._o)
+
+    def lvs (self):
+        return libguestfsmod.lvs (self._o)
+
+    def pvs_full (self):
+        return libguestfsmod.pvs_full (self._o)
+
+    def vgs_full (self):
+        return libguestfsmod.vgs_full (self._o)
+
+    def lvs_full (self):
+        return libguestfsmod.lvs_full (self._o)
+
+    def read_lines (self, path):
+        return libguestfsmod.read_lines (self._o, path)
+
+    def aug_init (self, root, flags):
+        return libguestfsmod.aug_init (self._o, root, flags)
+
+    def aug_close (self):
+        return libguestfsmod.aug_close (self._o)
+
+    def aug_defvar (self, name, expr):
+        return libguestfsmod.aug_defvar (self._o, name, expr)
+
+    def aug_defnode (self, name, expr, val):
+        return libguestfsmod.aug_defnode (self._o, name, expr, val)
+
+    def aug_get (self, path):
+        return libguestfsmod.aug_get (self._o, path)
+
+    def aug_set (self, path, val):
+        return libguestfsmod.aug_set (self._o, path, val)
+
+    def aug_insert (self, path, label, before):
+        return libguestfsmod.aug_insert (self._o, path, label, before)
+
+    def aug_rm (self, path):
+        return libguestfsmod.aug_rm (self._o, path)
+
+    def aug_mv (self, src, dest):
+        return libguestfsmod.aug_mv (self._o, src, dest)
+
+    def aug_match (self, path):
+        return libguestfsmod.aug_match (self._o, path)
+
+    def aug_save (self):
+        return libguestfsmod.aug_save (self._o)
+
+    def aug_load (self):
+        return libguestfsmod.aug_load (self._o)
+
+    def aug_ls (self, path):
+        return libguestfsmod.aug_ls (self._o, path)
+
+    def rm (self, path):
+        return libguestfsmod.rm (self._o, path)
+
+    def rmdir (self, path):
+        return libguestfsmod.rmdir (self._o, path)
+
+    def rm_rf (self, path):
+        return libguestfsmod.rm_rf (self._o, path)
+
+    def mkdir (self, path):
+        return libguestfsmod.mkdir (self._o, path)
+
+    def mkdir_p (self, path):
+        return libguestfsmod.mkdir_p (self._o, path)
+
+    def chmod (self, mode, path):
+        return libguestfsmod.chmod (self._o, mode, path)
+
+    def chown (self, owner, group, path):
+        return libguestfsmod.chown (self._o, owner, group, path)
+
+    def exists (self, path):
+        return libguestfsmod.exists (self._o, path)
+
+    def is_file (self, path):
+        return libguestfsmod.is_file (self._o, path)
+
+    def is_dir (self, path):
+        return libguestfsmod.is_dir (self._o, path)
+
+    def pvcreate (self, device):
+        return libguestfsmod.pvcreate (self._o, device)
+
+    def vgcreate (self, volgroup, physvols):
+        return libguestfsmod.vgcreate (self._o, volgroup, physvols)
+
+    def lvcreate (self, logvol, volgroup, mbytes):
+        return libguestfsmod.lvcreate (self._o, logvol, volgroup, mbytes)
+
+    def mkfs (self, fstype, device):
+        return libguestfsmod.mkfs (self._o, fstype, device)
+
+    def sfdisk (self, device, cyls, heads, sectors, lines):
+        return libguestfsmod.sfdisk (self._o, device, cyls, heads, sectors, lines)
+
+    def write_file (self, path, content, size):
+        return libguestfsmod.write_file (self._o, path, content, size)
+
+    def umount (self, pathordevice):
+        return libguestfsmod.umount (self._o, pathordevice)
+
+    def mounts (self):
+        return libguestfsmod.mounts (self._o)
+
+    def umount_all (self):
+        return libguestfsmod.umount_all (self._o)
+
+    def lvm_remove_all (self):
+        return libguestfsmod.lvm_remove_all (self._o)
+
diff --git a/python/t/005-import.py b/python/t/005-import.py
new file mode 100644
index 00000000..5896d15d
--- /dev/null
+++ b/python/t/005-import.py
@@ -0,0 +1,18 @@
+# libguestfs Python bindings
+# Copyright (C) 2009 Red Hat Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+import guestfs
diff --git a/python/t/010-launch.py b/python/t/010-launch.py
new file mode 100644
index 00000000..c2bdd1d0
--- /dev/null
+++ b/python/t/010-launch.py
@@ -0,0 +1,26 @@
+# libguestfs Python bindings
+# Copyright (C) 2009 Red Hat Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+import guestfs
+
+g = guestfs.guestfs()
+f = open ("test.img", "w")
+f.truncate (500 * 1024 * 1024)
+f.close ()
+g.add_drive ("test.img")
+g.launch ()
+g.wait_ready ()
diff --git a/python/t/050-lvcreate.py b/python/t/050-lvcreate.py
new file mode 100644
index 00000000..98227e23
--- /dev/null
+++ b/python/t/050-lvcreate.py
@@ -0,0 +1,37 @@
+# libguestfs Python bindings
+# Copyright (C) 2009 Red Hat Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+import guestfs
+
+g = guestfs.guestfs()
+f = open ("test.img", "w")
+f.truncate (500 * 1024 * 1024)
+f.close ()
+g.add_drive ("test.img")
+g.launch ()
+g.wait_ready ()
+g.pvcreate ("/dev/sda")
+g.vgcreate ("VG", ["/dev/sda"])
+g.lvcreate ("LV1", "VG", 200)
+g.lvcreate ("LV2", "VG", 200)
+if (g.lvs () != ["/dev/VG/LV1", "/dev/VG/LV2"]):
+    raise "Error: g.lvs() returned incorrect result"
+g.sync ()
+del g
+
+import os
+os.unlink ("test.img")