Remove generated code from git.

Git users now require the OCaml compiler in order to regenerate
the generated code after a checkout.

Generated code will remain in the tarball, so users of the
source tarball will not need the OCaml compiler.

1 files changed, 0 insertions, 1977 deletions

diff --git a/python/guestfs.py b/python/guestfs.py
deleted file mode 100644
index 784c5671..00000000
--- a/python/guestfs.py
+++ /dev/null
@@ -1,1977 +0,0 @@
-# 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
-
-u"""Python bindings for libguestfs
-
-import guestfs
-g = guestfs.GuestFS ()
-g.add_drive ("guest.img")
-g.launch ()
-g.wait_ready ()
-parts = g.list_partitions ()
-
-The guestfs module provides a Python binding to the libguestfs API
-for examining and modifying virtual machine disk images.
-
-Amongst the things this is good for: making batch configuration
-changes to guests, getting disk used/free statistics (see also:
-virt-df), migrating between virtualization systems (see also:
-virt-p2v), performing partial backups, performing partial guest
-clones, cloning guests and changing registry/UUID/hostname info, and
-much else besides.
-
-Libguestfs uses Linux kernel and qemu code, and can access any type of
-guest filesystem that Linux and qemu can, including but not limited
-to: ext2/3/4, btrfs, FAT and NTFS, LVM, many different disk partition
-schemes, qcow, qcow2, vmdk.
-
-Libguestfs provides ways to enumerate guest storage (eg. partitions,
-LVs, what filesystem is in each LV, etc.).  It can also run commands
-in the context of the guest.  Also you can access filesystems over FTP.
-
-Errors which happen while using the API are turned into Python
-RuntimeError exceptions.
-
-To create a guestfs handle you usually have to perform the following
-sequence of calls:
-
-# Create the handle, call add_drive at least once, and possibly
-# several times if the guest has multiple block devices:
-g = guestfs.GuestFS ()
-g.add_drive ("guest.img")
-
-# Launch the qemu subprocess and wait for it to become ready:
-g.launch ()
-g.wait_ready ()
-
-# Now you can issue commands, for example:
-logvols = g.lvs ()
-
-"""
-
-import libguestfsmod
-
-class GuestFS:
-    """Instances of this class are libguestfs API handles."""
-
-    def __init__ (self):
-        """Create a new libguestfs handle."""
-        self._o = libguestfsmod.create ()
-
-    def __del__ (self):
-        libguestfsmod.close (self._o)
-
-    def test0 (self, str, optstr, strlist, b, integer, filein, fileout):
-        return libguestfsmod.test0 (self._o, str, optstr, strlist, b, integer, filein, fileout)
-
-    def test0rint (self, val):
-        return libguestfsmod.test0rint (self._o, val)
-
-    def test0rinterr (self):
-        return libguestfsmod.test0rinterr (self._o)
-
-    def test0rint64 (self, val):
-        return libguestfsmod.test0rint64 (self._o, val)
-
-    def test0rint64err (self):
-        return libguestfsmod.test0rint64err (self._o)
-
-    def test0rbool (self, val):
-        return libguestfsmod.test0rbool (self._o, val)
-
-    def test0rboolerr (self):
-        return libguestfsmod.test0rboolerr (self._o)
-
-    def test0rconststring (self, val):
-        return libguestfsmod.test0rconststring (self._o, val)
-
-    def test0rconststringerr (self):
-        return libguestfsmod.test0rconststringerr (self._o)
-
-    def test0rstring (self, val):
-        return libguestfsmod.test0rstring (self._o, val)
-
-    def test0rstringerr (self):
-        return libguestfsmod.test0rstringerr (self._o)
-
-    def test0rstringlist (self, val):
-        return libguestfsmod.test0rstringlist (self._o, val)
-
-    def test0rstringlisterr (self):
-        return libguestfsmod.test0rstringlisterr (self._o)
-
-    def test0rintbool (self, val):
-        return libguestfsmod.test0rintbool (self._o, val)
-
-    def test0rintboolerr (self):
-        return libguestfsmod.test0rintboolerr (self._o)
-
-    def test0rpvlist (self, val):
-        return libguestfsmod.test0rpvlist (self._o, val)
-
-    def test0rpvlisterr (self):
-        return libguestfsmod.test0rpvlisterr (self._o)
-
-    def test0rvglist (self, val):
-        return libguestfsmod.test0rvglist (self._o, val)
-
-    def test0rvglisterr (self):
-        return libguestfsmod.test0rvglisterr (self._o)
-
-    def test0rlvlist (self, val):
-        return libguestfsmod.test0rlvlist (self._o, val)
-
-    def test0rlvlisterr (self):
-        return libguestfsmod.test0rlvlisterr (self._o)
-
-    def test0rstat (self, val):
-        return libguestfsmod.test0rstat (self._o, val)
-
-    def test0rstaterr (self):
-        return libguestfsmod.test0rstaterr (self._o)
-
-    def test0rstatvfs (self, val):
-        return libguestfsmod.test0rstatvfs (self._o, val)
-
-    def test0rstatvfserr (self):
-        return libguestfsmod.test0rstatvfserr (self._o)
-
-    def test0rhashtable (self, val):
-        return libguestfsmod.test0rhashtable (self._o, val)
-
-    def test0rhashtableerr (self):
-        return libguestfsmod.test0rhashtableerr (self._o)
-
-    def launch (self):
-        u"""Internally libguestfs is implemented by running a
-        virtual machine using qemu(1).
-        
-        You should call this after configuring the handle (eg.
-        adding drives) but before performing any actions.
-        """
-        return libguestfsmod.launch (self._o)
-
-    def wait_ready (self):
-        u"""Internally libguestfs is implemented by running a
-        virtual machine using qemu(1).
-        
-        You should call this after "g.launch" to wait for the
-        launch to complete.
-        """
-        return libguestfsmod.wait_ready (self._o)
-
-    def kill_subprocess (self):
-        u"""This kills the qemu subprocess. You should never need to
-        call this.
-        """
-        return libguestfsmod.kill_subprocess (self._o)
-
-    def add_drive (self, filename):
-        u"""This function adds a virtual machine disk image
-        "filename" to the guest. The first time you call this
-        function, the disk appears as IDE disk 0 ("/dev/sda") in
-        the guest, the second time as "/dev/sdb", and so on.
-        
-        You don't necessarily need to be root when using
-        libguestfs. However you obviously do need sufficient
-        permissions to access the filename for whatever
-        operations you want to perform (ie. read access if you
-        just want to read the image or write access if you want
-        to modify the image).
-        
-        This is equivalent to the qemu parameter "-drive
-        file=filename,cache=off,if=virtio".
-        
-        Note that this call checks for the existence of
-        "filename". This stops you from specifying other types
-        of drive which are supported by qemu such as "nbd:" and
-        "http:" URLs. To specify those, use the general
-        "g.config" call instead.
-        """
-        return libguestfsmod.add_drive (self._o, filename)
-
-    def add_cdrom (self, filename):
-        u"""This function adds a virtual CD-ROM disk image to the
-        guest.
-        
-        This is equivalent to the qemu parameter "-cdrom
-        filename".
-        
-        Note that this call checks for the existence of
-        "filename". This stops you from specifying other types
-        of drive which are supported by qemu such as "nbd:" and
-        "http:" URLs. To specify those, use the general
-        "g.config" call instead.
-        """
-        return libguestfsmod.add_cdrom (self._o, filename)
-
-    def add_drive_ro (self, filename):
-        u"""This adds a drive in snapshot mode, making it
-        effectively read-only.
-        
-        Note that writes to the device are allowed, and will be
-        seen for the duration of the guestfs handle, but they
-        are written to a temporary file which is discarded as
-        soon as the guestfs handle is closed. We don't currently
-        have any method to enable changes to be committed,
-        although qemu can support this.
-        
-        This is equivalent to the qemu parameter "-drive
-        file=filename,snapshot=on,if=virtio".
-        
-        Note that this call checks for the existence of
-        "filename". This stops you from specifying other types
-        of drive which are supported by qemu such as "nbd:" and
-        "http:" URLs. To specify those, use the general
-        "g.config" call instead.
-        """
-        return libguestfsmod.add_drive_ro (self._o, filename)
-
-    def config (self, qemuparam, qemuvalue):
-        u"""This can be used to add arbitrary qemu command line
-        parameters of the form "-param value". Actually it's not
-        quite arbitrary - we prevent you from setting some
-        parameters which would interfere with parameters that we
-        use.
-        
-        The first character of "param" string must be a "-"
-        (dash).
-        
-        "value" can be NULL.
-        """
-        return libguestfsmod.config (self._o, qemuparam, qemuvalue)
-
-    def set_qemu (self, qemu):
-        u"""Set the qemu binary that we will use.
-        
-        The default is chosen when the library was compiled by
-        the configure script.
-        
-        You can also override this by setting the
-        "LIBGUESTFS_QEMU" environment variable.
-        
-        Setting "qemu" to "NULL" restores the default qemu
-        binary.
-        """
-        return libguestfsmod.set_qemu (self._o, qemu)
-
-    def get_qemu (self):
-        u"""Return the current qemu binary.
-        
-        This is always non-NULL. If it wasn't set already, then
-        this will return the default qemu binary name.
-        """
-        return libguestfsmod.get_qemu (self._o)
-
-    def set_path (self, path):
-        u"""Set the path that libguestfs searches for kernel and
-        initrd.img.
-        
-        The default is "$libdir/guestfs" unless overridden by
-        setting "LIBGUESTFS_PATH" environment variable.
-        
-        Setting "path" to "NULL" restores the default path.
-        """
-        return libguestfsmod.set_path (self._o, path)
-
-    def get_path (self):
-        u"""Return the current search path.
-        
-        This is always non-NULL. If it wasn't set already, then
-        this will return the default path.
-        """
-        return libguestfsmod.get_path (self._o)
-
-    def set_append (self, append):
-        u"""This function is used to add additional options to the
-        guest kernel command line.
-        
-        The default is "NULL" unless overridden by setting
-        "LIBGUESTFS_APPEND" environment variable.
-        
-        Setting "append" to "NULL" means *no* additional options
-        are passed (libguestfs always adds a few of its own).
-        """
-        return libguestfsmod.set_append (self._o, append)
-
-    def get_append (self):
-        u"""Return the additional kernel options which are added to
-        the guest kernel command line.
-        
-        If "NULL" then no options are added.
-        """
-        return libguestfsmod.get_append (self._o)
-
-    def set_autosync (self, autosync):
-        u"""If "autosync" is true, this enables autosync. Libguestfs
-        will make a best effort attempt to run "g.umount_all"
-        followed by "g.sync" when the handle is closed (also if
-        the program exits without closing handles).
-        
-        This is disabled by default (except in guestfish where
-        it is enabled by default).
-        """
-        return libguestfsmod.set_autosync (self._o, autosync)
-
-    def get_autosync (self):
-        u"""Get the autosync flag.
-        """
-        return libguestfsmod.get_autosync (self._o)
-
-    def set_verbose (self, verbose):
-        u"""If "verbose" is true, this turns on verbose messages (to
-        "stderr").
-        
-        Verbose messages are disabled unless the environment
-        variable "LIBGUESTFS_DEBUG" is defined and set to 1.
-        """
-        return libguestfsmod.set_verbose (self._o, verbose)
-
-    def get_verbose (self):
-        u"""This returns the verbose messages flag.
-        """
-        return libguestfsmod.get_verbose (self._o)
-
-    def is_ready (self):
-        u"""This returns true iff this handle is ready to accept
-        commands (in the "READY" state).
-        
-        For more information on states, see guestfs(3).
-        """
-        return libguestfsmod.is_ready (self._o)
-
-    def is_config (self):
-        u"""This returns true iff this handle is being configured
-        (in the "CONFIG" state).
-        
-        For more information on states, see guestfs(3).
-        """
-        return libguestfsmod.is_config (self._o)
-
-    def is_launching (self):
-        u"""This returns true iff this handle is launching the
-        subprocess (in the "LAUNCHING" state).
-        
-        For more information on states, see guestfs(3).
-        """
-        return libguestfsmod.is_launching (self._o)
-
-    def is_busy (self):
-        u"""This returns true iff this handle is busy processing a
-        command (in the "BUSY" state).
-        
-        For more information on states, see guestfs(3).
-        """
-        return libguestfsmod.is_busy (self._o)
-
-    def get_state (self):
-        u"""This returns the current state as an opaque integer.
-        This is only useful for printing debug and internal
-        error messages.
-        
-        For more information on states, see guestfs(3).
-        """
-        return libguestfsmod.get_state (self._o)
-
-    def set_busy (self):
-        u"""This sets the state to "BUSY". This is only used when
-        implementing actions using the low-level API.
-        
-        For more information on states, see guestfs(3).
-        """
-        return libguestfsmod.set_busy (self._o)
-
-    def set_ready (self):
-        u"""This sets the state to "READY". This is only used when
-        implementing actions using the low-level API.
-        
-        For more information on states, see guestfs(3).
-        """
-        return libguestfsmod.set_ready (self._o)
-
-    def end_busy (self):
-        u"""This sets the state to "READY", or if in "CONFIG" then
-        it leaves the state as is. This is only used when
-        implementing actions using the low-level API.
-        
-        For more information on states, see guestfs(3).
-        """
-        return libguestfsmod.end_busy (self._o)
-
-    def set_memsize (self, memsize):
-        u"""This sets the memory size in megabytes allocated to the
-        qemu subprocess. This only has any effect if called
-        before "g.launch".
-        
-        You can also change this by setting the environment
-        variable "LIBGUESTFS_MEMSIZE" before the handle is
-        created.
-        
-        For more information on the architecture of libguestfs,
-        see guestfs(3).
-        """
-        return libguestfsmod.set_memsize (self._o, memsize)
-
-    def get_memsize (self):
-        u"""This gets the memory size in megabytes allocated to the
-        qemu subprocess.
-        
-        If "g.set_memsize" was not called on this handle, and if
-        "LIBGUESTFS_MEMSIZE" was not set, then this returns the
-        compiled-in default value for memsize.
-        
-        For more information on the architecture of libguestfs,
-        see guestfs(3).
-        """
-        return libguestfsmod.get_memsize (self._o)
-
-    def mount (self, device, mountpoint):
-        u"""Mount a guest disk at a position in the filesystem.
-        Block devices are named "/dev/sda", "/dev/sdb" and so
-        on, as they were added to the guest. If those block
-        devices contain partitions, they will have the usual
-        names (eg. "/dev/sda1"). Also LVM "/dev/VG/LV"-style
-        names can be used.
-        
-        The rules are the same as for mount(2): A filesystem
-        must first be mounted on "/" before others can be
-        mounted. Other filesystems can only be mounted on
-        directories which already exist.
-        
-        The mounted filesystem is writable, if we have
-        sufficient permissions on the underlying device.
-        
-        The filesystem options "sync" and "noatime" are set with
-        this call, in order to improve reliability.
-        """
-        return libguestfsmod.mount (self._o, device, mountpoint)
-
-    def sync (self):
-        u"""This syncs the disk, so that any writes are flushed
-        through to the underlying disk image.
-        
-        You should always call this if you have modified a disk
-        image, before closing the handle.
-        """
-        return libguestfsmod.sync (self._o)
-
-    def touch (self, path):
-        u"""Touch acts like the touch(1) command. It can be used to
-        update the timestamps on a file, or, if the file does
-        not exist, to create a new zero-length file.
-        """
-        return libguestfsmod.touch (self._o, path)
-
-    def cat (self, path):
-        u"""Return the contents of the file named "path".
-        
-        Note that this function cannot correctly handle binary
-        files (specifically, files containing "\\0" character
-        which is treated as end of string). For those you need
-        to use the "g.download" function which has a more
-        complex interface.
-        
-        Because of the message protocol, there is a transfer
-        limit of somewhere between 2MB and 4MB. To transfer
-        large files you should use FTP.
-        """
-        return libguestfsmod.cat (self._o, path)
-
-    def ll (self, directory):
-        u"""List the files in "directory" (relative to the root
-        directory, there is no cwd) in the format of 'ls -la'.
-        
-        This command is mostly useful for interactive sessions.
-        It is *not* intended that you try to parse the output
-        string.
-        """
-        return libguestfsmod.ll (self._o, directory)
-
-    def ls (self, directory):
-        u"""List the files in "directory" (relative to the root
-        directory, there is no cwd). The '.' and '..' entries
-        are not returned, but hidden files are shown.
-        
-        This command is mostly useful for interactive sessions.
-        Programs should probably use "g.readdir" instead.
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.ls (self._o, directory)
-
-    def list_devices (self):
-        u"""List all the block devices.
-        
-        The full block device names are returned, eg. "/dev/sda"
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.list_devices (self._o)
-
-    def list_partitions (self):
-        u"""List all the partitions detected on all block devices.
-        
-        The full partition device names are returned, eg.
-        "/dev/sda1"
-        
-        This does not return logical volumes. For that you will
-        need to call "g.lvs".
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.list_partitions (self._o)
-
-    def pvs (self):
-        u"""List all the physical volumes detected. This is the
-        equivalent of the pvs(8) command.
-        
-        This returns a list of just the device names that
-        contain PVs (eg. "/dev/sda2").
-        
-        See also "g.pvs_full".
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.pvs (self._o)
-
-    def vgs (self):
-        u"""List all the volumes groups detected. This is the
-        equivalent of the vgs(8) command.
-        
-        This returns a list of just the volume group names that
-        were detected (eg. "VolGroup00").
-        
-        See also "g.vgs_full".
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.vgs (self._o)
-
-    def lvs (self):
-        u"""List all the logical volumes detected. This is the
-        equivalent of the lvs(8) command.
-        
-        This returns a list of the logical volume device names
-        (eg. "/dev/VolGroup00/LogVol00").
-        
-        See also "g.lvs_full".
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.lvs (self._o)
-
-    def pvs_full (self):
-        u"""List all the physical volumes detected. This is the
-        equivalent of the pvs(8) command. The "full" version
-        includes all fields.
-        
-        This function returns a list of PVs. Each PV is
-        represented as a dictionary.
-        """
-        return libguestfsmod.pvs_full (self._o)
-
-    def vgs_full (self):
-        u"""List all the volumes groups detected. This is the
-        equivalent of the vgs(8) command. The "full" version
-        includes all fields.
-        
-        This function returns a list of VGs. Each VG is
-        represented as a dictionary.
-        """
-        return libguestfsmod.vgs_full (self._o)
-
-    def lvs_full (self):
-        u"""List all the logical volumes detected. This is the
-        equivalent of the lvs(8) command. The "full" version
-        includes all fields.
-        
-        This function returns a list of LVs. Each LV is
-        represented as a dictionary.
-        """
-        return libguestfsmod.lvs_full (self._o)
-
-    def read_lines (self, path):
-        u"""Return the contents of the file named "path".
-        
-        The file contents are returned as a list of lines.
-        Trailing "LF" and "CRLF" character sequences are *not*
-        returned.
-        
-        Note that this function cannot correctly handle binary
-        files (specifically, files containing "\\0" character
-        which is treated as end of line). For those you need to
-        use the "g.read_file" function which has a more complex
-        interface.
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.read_lines (self._o, path)
-
-    def aug_init (self, root, flags):
-        u"""Create a new Augeas handle for editing configuration
-        files. If there was any previous Augeas handle
-        associated with this guestfs session, then it is closed.
-        
-        You must call this before using any other "g.aug_*"
-        commands.
-        
-        "root" is the filesystem root. "root" must not be NULL,
-        use "/" instead.
-        
-        The flags are the same as the flags defined in
-        <augeas.h>, the logical *or* of the following integers:
-        
-        "AUG_SAVE_BACKUP" = 1
-        Keep the original file with a ".augsave" extension.
-        
-        "AUG_SAVE_NEWFILE" = 2
-        Save changes into a file with extension ".augnew",
-        and do not overwrite original. Overrides
-        "AUG_SAVE_BACKUP".
-        
-        "AUG_TYPE_CHECK" = 4
-        Typecheck lenses (can be expensive).
-        
-        "AUG_NO_STDINC" = 8
-        Do not use standard load path for modules.
-        
-        "AUG_SAVE_NOOP" = 16
-        Make save a no-op, just record what would have been
-        changed.
-        
-        "AUG_NO_LOAD" = 32
-        Do not load the tree in "g.aug_init".
-        
-        To close the handle, you can call "g.aug_close".
-        
-        To find out more about Augeas, see <http://augeas.net/>.
-        """
-        return libguestfsmod.aug_init (self._o, root, flags)
-
-    def aug_close (self):
-        u"""Close the current Augeas handle and free up any
-        resources used by it. After calling this, you have to
-        call "g.aug_init" again before you can use any other
-        Augeas functions.
-        """
-        return libguestfsmod.aug_close (self._o)
-
-    def aug_defvar (self, name, expr):
-        u"""Defines an Augeas variable "name" whose value is the
-        result of evaluating "expr". If "expr" is NULL, then
-        "name" is undefined.
-        
-        On success this returns the number of nodes in "expr",
-        or 0 if "expr" evaluates to something which is not a
-        nodeset.
-        """
-        return libguestfsmod.aug_defvar (self._o, name, expr)
-
-    def aug_defnode (self, name, expr, val):
-        u"""Defines a variable "name" whose value is the result of
-        evaluating "expr".
-        
-        If "expr" evaluates to an empty nodeset, a node is
-        created, equivalent to calling "g.aug_set" "expr",
-        "value". "name" will be the nodeset containing that
-        single node.
-        
-        On success this returns a pair containing the number of
-        nodes in the nodeset, and a boolean flag if a node was
-        created.
-        
-        This function returns a tuple (int, bool).
-        """
-        return libguestfsmod.aug_defnode (self._o, name, expr, val)
-
-    def aug_get (self, path):
-        u"""Look up the value associated with "path". If "path"
-        matches exactly one node, the "value" is returned.
-        """
-        return libguestfsmod.aug_get (self._o, path)
-
-    def aug_set (self, path, val):
-        u"""Set the value associated with "path" to "value".
-        """
-        return libguestfsmod.aug_set (self._o, path, val)
-
-    def aug_insert (self, path, label, before):
-        u"""Create a new sibling "label" for "path", inserting it
-        into the tree before or after "path" (depending on the
-        boolean flag "before").
-        
-        "path" must match exactly one existing node in the tree,
-        and "label" must be a label, ie. not contain "/", "*" or
-        end with a bracketed index "[N]".
-        """
-        return libguestfsmod.aug_insert (self._o, path, label, before)
-
-    def aug_rm (self, path):
-        u"""Remove "path" and all of its children.
-        
-        On success this returns the number of entries which were
-        removed.
-        """
-        return libguestfsmod.aug_rm (self._o, path)
-
-    def aug_mv (self, src, dest):
-        u"""Move the node "src" to "dest". "src" must match exactly
-        one node. "dest" is overwritten if it exists.
-        """
-        return libguestfsmod.aug_mv (self._o, src, dest)
-
-    def aug_match (self, path):
-        u"""Returns a list of paths which match the path expression
-        "path". The returned paths are sufficiently qualified so
-        that they match exactly one node in the current tree.
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.aug_match (self._o, path)
-
-    def aug_save (self):
-        u"""This writes all pending changes to disk.
-        
-        The flags which were passed to "g.aug_init" affect
-        exactly how files are saved.
-        """
-        return libguestfsmod.aug_save (self._o)
-
-    def aug_load (self):
-        u"""Load files into the tree.
-        
-        See "aug_load" in the Augeas documentation for the full
-        gory details.
-        """
-        return libguestfsmod.aug_load (self._o)
-
-    def aug_ls (self, path):
-        u"""This is just a shortcut for listing "g.aug_match"
-        "path/*" and sorting the resulting nodes into
-        alphabetical order.
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.aug_ls (self._o, path)
-
-    def rm (self, path):
-        u"""Remove the single file "path".
-        """
-        return libguestfsmod.rm (self._o, path)
-
-    def rmdir (self, path):
-        u"""Remove the single directory "path".
-        """
-        return libguestfsmod.rmdir (self._o, path)
-
-    def rm_rf (self, path):
-        u"""Remove the file or directory "path", recursively
-        removing the contents if its a directory. This is like
-        the "rm -rf" shell command.
-        """
-        return libguestfsmod.rm_rf (self._o, path)
-
-    def mkdir (self, path):
-        u"""Create a directory named "path".
-        """
-        return libguestfsmod.mkdir (self._o, path)
-
-    def mkdir_p (self, path):
-        u"""Create a directory named "path", creating any parent
-        directories as necessary. This is like the "mkdir -p"
-        shell command.
-        """
-        return libguestfsmod.mkdir_p (self._o, path)
-
-    def chmod (self, mode, path):
-        u"""Change the mode (permissions) of "path" to "mode". Only
-        numeric modes are supported.
-        """
-        return libguestfsmod.chmod (self._o, mode, path)
-
-    def chown (self, owner, group, path):
-        u"""Change the file owner to "owner" and group to "group".
-        
-        Only numeric uid and gid are supported. If you want to
-        use names, you will need to locate and parse the
-        password file yourself (Augeas support makes this
-        relatively easy).
-        """
-        return libguestfsmod.chown (self._o, owner, group, path)
-
-    def exists (self, path):
-        u"""This returns "true" if and only if there is a file,
-        directory (or anything) with the given "path" name.
-        
-        See also "g.is_file", "g.is_dir", "g.stat".
-        """
-        return libguestfsmod.exists (self._o, path)
-
-    def is_file (self, path):
-        u"""This returns "true" if and only if there is a file with
-        the given "path" name. Note that it returns false for
-        other objects like directories.
-        
-        See also "g.stat".
-        """
-        return libguestfsmod.is_file (self._o, path)
-
-    def is_dir (self, path):
-        u"""This returns "true" if and only if there is a directory
-        with the given "path" name. Note that it returns false
-        for other objects like files.
-        
-        See also "g.stat".
-        """
-        return libguestfsmod.is_dir (self._o, path)
-
-    def pvcreate (self, device):
-        u"""This creates an LVM physical volume on the named
-        "device", where "device" should usually be a partition
-        name such as "/dev/sda1".
-        """
-        return libguestfsmod.pvcreate (self._o, device)
-
-    def vgcreate (self, volgroup, physvols):
-        u"""This creates an LVM volume group called "volgroup" from
-        the non-empty list of physical volumes "physvols".
-        """
-        return libguestfsmod.vgcreate (self._o, volgroup, physvols)
-
-    def lvcreate (self, logvol, volgroup, mbytes):
-        u"""This creates an LVM volume group called "logvol" on the
-        volume group "volgroup", with "size" megabytes.
-        """
-        return libguestfsmod.lvcreate (self._o, logvol, volgroup, mbytes)
-
-    def mkfs (self, fstype, device):
-        u"""This creates a filesystem on "device" (usually a
-        partition or LVM logical volume). The filesystem type is
-        "fstype", for example "ext3".
-        """
-        return libguestfsmod.mkfs (self._o, fstype, device)
-
-    def sfdisk (self, device, cyls, heads, sectors, lines):
-        u"""This is a direct interface to the sfdisk(8) program for
-        creating partitions on block devices.
-        
-        "device" should be a block device, for example
-        "/dev/sda".
-        
-        "cyls", "heads" and "sectors" are the number of
-        cylinders, heads and sectors on the device, which are
-        passed directly to sfdisk as the *-C*, *-H* and *-S*
-        parameters. If you pass 0 for any of these, then the
-        corresponding parameter is omitted. Usually for 'large'
-        disks, you can just pass 0 for these, but for small
-        (floppy-sized) disks, sfdisk (or rather, the kernel)
-        cannot work out the right geometry and you will need to
-        tell it.
-        
-        "lines" is a list of lines that we feed to "sfdisk". For
-        more information refer to the sfdisk(8) manpage.
-        
-        To create a single partition occupying the whole disk,
-        you would pass "lines" as a single element list, when
-        the single element being the string "," (comma).
-        
-        See also: "g.sfdisk_l", "g.sfdisk_N"
-        
-        This command is dangerous. Without careful use you can
-        easily destroy all your data.
-        """
-        return libguestfsmod.sfdisk (self._o, device, cyls, heads, sectors, lines)
-
-    def write_file (self, path, content, size):
-        u"""This call creates a file called "path". The contents of
-        the file is the string "content" (which can contain any
-        8 bit data), with length "size".
-        
-        As a special case, if "size" is 0 then the length is
-        calculated using "strlen" (so in this case the content
-        cannot contain embedded ASCII NULs).
-        
-        *NB.* Owing to a bug, writing content containing ASCII
-        NUL characters does *not* work, even if the length is
-        specified. We hope to resolve this bug in a future
-        version. In the meantime use "g.upload".
-        
-        Because of the message protocol, there is a transfer
-        limit of somewhere between 2MB and 4MB. To transfer
-        large files you should use FTP.
-        """
-        return libguestfsmod.write_file (self._o, path, content, size)
-
-    def umount (self, pathordevice):
-        u"""This unmounts the given filesystem. The filesystem may
-        be specified either by its mountpoint (path) or the
-        device which contains the filesystem.
-        """
-        return libguestfsmod.umount (self._o, pathordevice)
-
-    def mounts (self):
-        u"""This returns the list of currently mounted filesystems.
-        It returns the list of devices (eg. "/dev/sda1",
-        "/dev/VG/LV").
-        
-        Some internal mounts are not shown.
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.mounts (self._o)
-
-    def umount_all (self):
-        u"""This unmounts all mounted filesystems.
-        
-        Some internal mounts are not unmounted by this call.
-        """
-        return libguestfsmod.umount_all (self._o)
-
-    def lvm_remove_all (self):
-        u"""This command removes all LVM logical volumes, volume
-        groups and physical volumes.
-        
-        This command is dangerous. Without careful use you can
-        easily destroy all your data.
-        """
-        return libguestfsmod.lvm_remove_all (self._o)
-
-    def file (self, path):
-        u"""This call uses the standard file(1) command to determine
-        the type or contents of the file. This also works on
-        devices, for example to find out whether a partition
-        contains a filesystem.
-        
-        The exact command which runs is "file -bsL path". Note
-        in particular that the filename is not prepended to the
-        output (the "-b" option).
-        """
-        return libguestfsmod.file (self._o, path)
-
-    def command (self, arguments):
-        u"""This call runs a command from the guest filesystem. The
-        filesystem must be mounted, and must contain a
-        compatible operating system (ie. something Linux, with
-        the same or compatible processor architecture).
-        
-        The single parameter is an argv-style list of arguments.
-        The first element is the name of the program to run.
-        Subsequent elements are parameters. The list must be
-        non-empty (ie. must contain a program name). Note that
-        the command runs directly, and is *not* invoked via the
-        shell (see "g.sh").
-        
-        The return value is anything printed to *stdout* by the
-        command.
-        
-        If the command returns a non-zero exit status, then this
-        function returns an error message. The error message
-        string is the content of *stderr* from the command.
-        
-        The $PATH environment variable will contain at least
-        "/usr/bin" and "/bin". If you require a program from
-        another location, you should provide the full path in
-        the first parameter.
-        
-        Shared libraries and data files required by the program
-        must be available on filesystems which are mounted in
-        the correct places. It is the caller's responsibility to
-        ensure all filesystems that are needed are mounted at
-        the right locations.
-        
-        Because of the message protocol, there is a transfer
-        limit of somewhere between 2MB and 4MB. To transfer
-        large files you should use FTP.
-        """
-        return libguestfsmod.command (self._o, arguments)
-
-    def command_lines (self, arguments):
-        u"""This is the same as "g.command", but splits the result
-        into a list of lines.
-        
-        See also: "g.sh_lines"
-        
-        This function returns a list of strings.
-        
-        Because of the message protocol, there is a transfer
-        limit of somewhere between 2MB and 4MB. To transfer
-        large files you should use FTP.
-        """
-        return libguestfsmod.command_lines (self._o, arguments)
-
-    def stat (self, path):
-        u"""Returns file information for the given "path".
-        
-        This is the same as the stat(2) system call.
-        
-        This function returns a dictionary, with keys matching
-        the various fields in the stat structure.
-        """
-        return libguestfsmod.stat (self._o, path)
-
-    def lstat (self, path):
-        u"""Returns file information for the given "path".
-        
-        This is the same as "g.stat" except that if "path" is a
-        symbolic link, then the link is stat-ed, not the file it
-        refers to.
-        
-        This is the same as the lstat(2) system call.
-        
-        This function returns a dictionary, with keys matching
-        the various fields in the stat structure.
-        """
-        return libguestfsmod.lstat (self._o, path)
-
-    def statvfs (self, path):
-        u"""Returns file system statistics for any mounted file
-        system. "path" should be a file or directory in the
-        mounted file system (typically it is the mount point
-        itself, but it doesn't need to be).
-        
-        This is the same as the statvfs(2) system call.
-        
-        This function returns a dictionary, with keys matching
-        the various fields in the statvfs structure.
-        """
-        return libguestfsmod.statvfs (self._o, path)
-
-    def tune2fs_l (self, device):
-        u"""This returns the contents of the ext2, ext3 or ext4
-        filesystem superblock on "device".
-        
-        It is the same as running "tune2fs -l device". See
-        tune2fs(8) manpage for more details. The list of fields
-        returned isn't clearly defined, and depends on both the
-        version of "tune2fs" that libguestfs was built against,
-        and the filesystem itself.
-        
-        This function returns a dictionary.
-        """
-        return libguestfsmod.tune2fs_l (self._o, device)
-
-    def blockdev_setro (self, device):
-        u"""Sets the block device named "device" to read-only.
-        
-        This uses the blockdev(8) command.
-        """
-        return libguestfsmod.blockdev_setro (self._o, device)
-
-    def blockdev_setrw (self, device):
-        u"""Sets the block device named "device" to read-write.
-        
-        This uses the blockdev(8) command.
-        """
-        return libguestfsmod.blockdev_setrw (self._o, device)
-
-    def blockdev_getro (self, device):
-        u"""Returns a boolean indicating if the block device is
-        read-only (true if read-only, false if not).
-        
-        This uses the blockdev(8) command.
-        """
-        return libguestfsmod.blockdev_getro (self._o, device)
-
-    def blockdev_getss (self, device):
-        u"""This returns the size of sectors on a block device.
-        Usually 512, but can be larger for modern devices.
-        
-        (Note, this is not the size in sectors, use
-        "g.blockdev_getsz" for that).
-        
-        This uses the blockdev(8) command.
-        """
-        return libguestfsmod.blockdev_getss (self._o, device)
-
-    def blockdev_getbsz (self, device):
-        u"""This returns the block size of a device.
-        
-        (Note this is different from both *size in blocks* and
-        *filesystem block size*).
-        
-        This uses the blockdev(8) command.
-        """
-        return libguestfsmod.blockdev_getbsz (self._o, device)
-
-    def blockdev_setbsz (self, device, blocksize):
-        u"""This sets the block size of a device.
-        
-        (Note this is different from both *size in blocks* and
-        *filesystem block size*).
-        
-        This uses the blockdev(8) command.
-        """
-        return libguestfsmod.blockdev_setbsz (self._o, device, blocksize)
-
-    def blockdev_getsz (self, device):
-        u"""This returns the size of the device in units of 512-byte
-        sectors (even if the sectorsize isn't 512 bytes ...
-        weird).
-        
-        See also "g.blockdev_getss" for the real sector size of
-        the device, and "g.blockdev_getsize64" for the more
-        useful *size in bytes*.
-        
-        This uses the blockdev(8) command.
-        """
-        return libguestfsmod.blockdev_getsz (self._o, device)
-
-    def blockdev_getsize64 (self, device):
-        u"""This returns the size of the device in bytes.
-        
-        See also "g.blockdev_getsz".
-        
-        This uses the blockdev(8) command.
-        """
-        return libguestfsmod.blockdev_getsize64 (self._o, device)
-
-    def blockdev_flushbufs (self, device):
-        u"""This tells the kernel to flush internal buffers
-        associated with "device".
-        
-        This uses the blockdev(8) command.
-        """
-        return libguestfsmod.blockdev_flushbufs (self._o, device)
-
-    def blockdev_rereadpt (self, device):
-        u"""Reread the partition table on "device".
-        
-        This uses the blockdev(8) command.
-        """
-        return libguestfsmod.blockdev_rereadpt (self._o, device)
-
-    def upload (self, filename, remotefilename):
-        u"""Upload local file "filename" to "remotefilename" on the
-        filesystem.
-        
-        "filename" can also be a named pipe.
-        
-        See also "g.download".
-        """
-        return libguestfsmod.upload (self._o, filename, remotefilename)
-
-    def download (self, remotefilename, filename):
-        u"""Download file "remotefilename" and save it as "filename"
-        on the local machine.
-        
-        "filename" can also be a named pipe.
-        
-        See also "g.upload", "g.cat".
-        """
-        return libguestfsmod.download (self._o, remotefilename, filename)
-
-    def checksum (self, csumtype, path):
-        u"""This call computes the MD5, SHAx or CRC checksum of the
-        file named "path".
-        
-        The type of checksum to compute is given by the
-        "csumtype" parameter which must have one of the
-        following values:
-        
-        "crc"
-        Compute the cyclic redundancy check (CRC) specified
-        by POSIX for the "cksum" command.
-        
-        "md5"
-        Compute the MD5 hash (using the "md5sum" program).
-        
-        "sha1"
-        Compute the SHA1 hash (using the "sha1sum" program).
-        
-        "sha224"
-        Compute the SHA224 hash (using the "sha224sum"
-        program).
-        
-        "sha256"
-        Compute the SHA256 hash (using the "sha256sum"
-        program).
-        
-        "sha384"
-        Compute the SHA384 hash (using the "sha384sum"
-        program).
-        
-        "sha512"
-        Compute the SHA512 hash (using the "sha512sum"
-        program).
-        
-        The checksum is returned as a printable string.
-        """
-        return libguestfsmod.checksum (self._o, csumtype, path)
-
-    def tar_in (self, tarfile, directory):
-        u"""This command uploads and unpacks local file "tarfile"
-        (an *uncompressed* tar file) into "directory".
-        
-        To upload a compressed tarball, use "g.tgz_in".
-        """
-        return libguestfsmod.tar_in (self._o, tarfile, directory)
-
-    def tar_out (self, directory, tarfile):
-        u"""This command packs the contents of "directory" and
-        downloads it to local file "tarfile".
-        
-        To download a compressed tarball, use "g.tgz_out".
-        """
-        return libguestfsmod.tar_out (self._o, directory, tarfile)
-
-    def tgz_in (self, tarball, directory):
-        u"""This command uploads and unpacks local file "tarball" (a
-        *gzip compressed* tar file) into "directory".
-        
-        To upload an uncompressed tarball, use "g.tar_in".
-        """
-        return libguestfsmod.tgz_in (self._o, tarball, directory)
-
-    def tgz_out (self, directory, tarball):
-        u"""This command packs the contents of "directory" and
-        downloads it to local file "tarball".
-        
-        To download an uncompressed tarball, use "g.tar_out".
-        """
-        return libguestfsmod.tgz_out (self._o, directory, tarball)
-
-    def mount_ro (self, device, mountpoint):
-        u"""This is the same as the "g.mount" command, but it mounts
-        the filesystem with the read-only (*-o ro*) flag.
-        """
-        return libguestfsmod.mount_ro (self._o, device, mountpoint)
-
-    def mount_options (self, options, device, mountpoint):
-        u"""This is the same as the "g.mount" command, but it allows
-        you to set the mount options as for the mount(8) *-o*
-        flag.
-        """
-        return libguestfsmod.mount_options (self._o, options, device, mountpoint)
-
-    def mount_vfs (self, options, vfstype, device, mountpoint):
-        u"""This is the same as the "g.mount" command, but it allows
-        you to set both the mount options and the vfstype as for
-        the mount(8) *-o* and *-t* flags.
-        """
-        return libguestfsmod.mount_vfs (self._o, options, vfstype, device, mountpoint)
-
-    def debug (self, subcmd, extraargs):
-        u"""The "g.debug" command exposes some internals of
-        "guestfsd" (the guestfs daemon) that runs inside the
-        qemu subprocess.
-        
-        There is no comprehensive help for this command. You
-        have to look at the file "daemon/debug.c" in the
-        libguestfs source to find out what you can do.
-        """
-        return libguestfsmod.debug (self._o, subcmd, extraargs)
-
-    def lvremove (self, device):
-        u"""Remove an LVM logical volume "device", where "device" is
-        the path to the LV, such as "/dev/VG/LV".
-        
-        You can also remove all LVs in a volume group by
-        specifying the VG name, "/dev/VG".
-        """
-        return libguestfsmod.lvremove (self._o, device)
-
-    def vgremove (self, vgname):
-        u"""Remove an LVM volume group "vgname", (for example "VG").
-        
-        This also forcibly removes all logical volumes in the
-        volume group (if any).
-        """
-        return libguestfsmod.vgremove (self._o, vgname)
-
-    def pvremove (self, device):
-        u"""This wipes a physical volume "device" so that LVM will
-        no longer recognise it.
-        
-        The implementation uses the "pvremove" command which
-        refuses to wipe physical volumes that contain any volume
-        groups, so you have to remove those first.
-        """
-        return libguestfsmod.pvremove (self._o, device)
-
-    def set_e2label (self, device, label):
-        u"""This sets the ext2/3/4 filesystem label of the
-        filesystem on "device" to "label". Filesystem labels are
-        limited to 16 characters.
-        
-        You can use either "g.tune2fs_l" or "g.get_e2label" to
-        return the existing label on a filesystem.
-        """
-        return libguestfsmod.set_e2label (self._o, device, label)
-
-    def get_e2label (self, device):
-        u"""This returns the ext2/3/4 filesystem label of the
-        filesystem on "device".
-        """
-        return libguestfsmod.get_e2label (self._o, device)
-
-    def set_e2uuid (self, device, uuid):
-        u"""This sets the ext2/3/4 filesystem UUID of the filesystem
-        on "device" to "uuid". The format of the UUID and
-        alternatives such as "clear", "random" and "time" are
-        described in the tune2fs(8) manpage.
-        
-        You can use either "g.tune2fs_l" or "g.get_e2uuid" to
-        return the existing UUID of a filesystem.
-        """
-        return libguestfsmod.set_e2uuid (self._o, device, uuid)
-
-    def get_e2uuid (self, device):
-        u"""This returns the ext2/3/4 filesystem UUID of the
-        filesystem on "device".
-        """
-        return libguestfsmod.get_e2uuid (self._o, device)
-
-    def fsck (self, fstype, device):
-        u"""This runs the filesystem checker (fsck) on "device"
-        which should have filesystem type "fstype".
-        
-        The returned integer is the status. See fsck(8) for the
-        list of status codes from "fsck".
-        
-        Notes:
-        
-        *   Multiple status codes can be summed together.
-        
-        *   A non-zero return code can mean "success", for
-        example if errors have been corrected on the
-        filesystem.
-        
-        *   Checking or repairing NTFS volumes is not supported
-        (by linux-ntfs).
-        
-        This command is entirely equivalent to running "fsck -a
-        -t fstype device".
-        """
-        return libguestfsmod.fsck (self._o, fstype, device)
-
-    def zero (self, device):
-        u"""This command writes zeroes over the first few blocks of
-        "device".
-        
-        How many blocks are zeroed isn't specified (but it's
-        *not* enough to securely wipe the device). It should be
-        sufficient to remove any partition tables, filesystem
-        superblocks and so on.
-        
-        See also: "g.scrub_device".
-        """
-        return libguestfsmod.zero (self._o, device)
-
-    def grub_install (self, root, device):
-        u"""This command installs GRUB (the Grand Unified
-        Bootloader) on "device", with the root directory being
-        "root".
-        """
-        return libguestfsmod.grub_install (self._o, root, device)
-
-    def cp (self, src, dest):
-        u"""This copies a file from "src" to "dest" where "dest" is
-        either a destination filename or destination directory.
-        """
-        return libguestfsmod.cp (self._o, src, dest)
-
-    def cp_a (self, src, dest):
-        u"""This copies a file or directory from "src" to "dest"
-        recursively using the "cp -a" command.
-        """
-        return libguestfsmod.cp_a (self._o, src, dest)
-
-    def mv (self, src, dest):
-        u"""This moves a file from "src" to "dest" where "dest" is
-        either a destination filename or destination directory.
-        """
-        return libguestfsmod.mv (self._o, src, dest)
-
-    def drop_caches (self, whattodrop):
-        u"""This instructs the guest kernel to drop its page cache,
-        and/or dentries and inode caches. The parameter
-        "whattodrop" tells the kernel what precisely to drop,
-        see <http://linux-mm.org/Drop_Caches>
-        
-        Setting "whattodrop" to 3 should drop everything.
-        
-        This automatically calls sync(2) before the operation,
-        so that the maximum guest memory is freed.
-        """
-        return libguestfsmod.drop_caches (self._o, whattodrop)
-
-    def dmesg (self):
-        u"""This returns the kernel messages ("dmesg" output) from
-        the guest kernel. This is sometimes useful for extended
-        debugging of problems.
-        
-        Another way to get the same information is to enable
-        verbose messages with "g.set_verbose" or by setting the
-        environment variable "LIBGUESTFS_DEBUG=1" before running
-        the program.
-        """
-        return libguestfsmod.dmesg (self._o)
-
-    def ping_daemon (self):
-        u"""This is a test probe into the guestfs daemon running
-        inside the qemu subprocess. Calling this function checks
-        that the daemon responds to the ping message, without
-        affecting the daemon or attached block device(s) in any
-        other way.
-        """
-        return libguestfsmod.ping_daemon (self._o)
-
-    def equal (self, file1, file2):
-        u"""This compares the two files "file1" and "file2" and
-        returns true if their content is exactly equal, or false
-        otherwise.
-        
-        The external cmp(1) program is used for the comparison.
-        """
-        return libguestfsmod.equal (self._o, file1, file2)
-
-    def strings (self, path):
-        u"""This runs the strings(1) command on a file and returns
-        the list of printable strings found.
-        
-        This function returns a list of strings.
-        
-        Because of the message protocol, there is a transfer
-        limit of somewhere between 2MB and 4MB. To transfer
-        large files you should use FTP.
-        """
-        return libguestfsmod.strings (self._o, path)
-
-    def strings_e (self, encoding, path):
-        u"""This is like the "g.strings" command, but allows you to
-        specify the encoding.
-        
-        See the strings(1) manpage for the full list of
-        encodings.
-        
-        Commonly useful encodings are "l" (lower case L) which
-        will show strings inside Windows/x86 files.
-        
-        The returned strings are transcoded to UTF-8.
-        
-        This function returns a list of strings.
-        
-        Because of the message protocol, there is a transfer
-        limit of somewhere between 2MB and 4MB. To transfer
-        large files you should use FTP.
-        """
-        return libguestfsmod.strings_e (self._o, encoding, path)
-
-    def hexdump (self, path):
-        u"""This runs "hexdump -C" on the given "path". The result
-        is the human-readable, canonical hex dump of the file.
-        
-        Because of the message protocol, there is a transfer
-        limit of somewhere between 2MB and 4MB. To transfer
-        large files you should use FTP.
-        """
-        return libguestfsmod.hexdump (self._o, path)
-
-    def zerofree (self, device):
-        u"""This runs the *zerofree* program on "device". This
-        program claims to zero unused inodes and disk blocks on
-        an ext2/3 filesystem, thus making it possible to
-        compress the filesystem more effectively.
-        
-        You should not run this program if the filesystem is
-        mounted.
-        
-        It is possible that using this program can damage the
-        filesystem or data on the filesystem.
-        """
-        return libguestfsmod.zerofree (self._o, device)
-
-    def pvresize (self, device):
-        u"""This resizes (expands or shrinks) an existing LVM
-        physical volume to match the new size of the underlying
-        device.
-        """
-        return libguestfsmod.pvresize (self._o, device)
-
-    def sfdisk_N (self, device, partnum, cyls, heads, sectors, line):
-        u"""This runs sfdisk(8) option to modify just the single
-        partition "n" (note: "n" counts from 1).
-        
-        For other parameters, see "g.sfdisk". You should usually
-        pass 0 for the cyls/heads/sectors parameters.
-        
-        This command is dangerous. Without careful use you can
-        easily destroy all your data.
-        """
-        return libguestfsmod.sfdisk_N (self._o, device, partnum, cyls, heads, sectors, line)
-
-    def sfdisk_l (self, device):
-        u"""This displays the partition table on "device", in the
-        human-readable output of the sfdisk(8) command. It is
-        not intended to be parsed.
-        """
-        return libguestfsmod.sfdisk_l (self._o, device)
-
-    def sfdisk_kernel_geometry (self, device):
-        u"""This displays the kernel's idea of the geometry of
-        "device".
-        
-        The result is in human-readable format, and not designed
-        to be parsed.
-        """
-        return libguestfsmod.sfdisk_kernel_geometry (self._o, device)
-
-    def sfdisk_disk_geometry (self, device):
-        u"""This displays the disk geometry of "device" read from
-        the partition table. Especially in the case where the
-        underlying block device has been resized, this can be
-        different from the kernel's idea of the geometry (see
-        "g.sfdisk_kernel_geometry").
-        
-        The result is in human-readable format, and not designed
-        to be parsed.
-        """
-        return libguestfsmod.sfdisk_disk_geometry (self._o, device)
-
-    def vg_activate_all (self, activate):
-        u"""This command activates or (if "activate" is false)
-        deactivates all logical volumes in all volume groups. If
-        activated, then they are made known to the kernel, ie.
-        they appear as "/dev/mapper" devices. If deactivated,
-        then those devices disappear.
-        
-        This command is the same as running "vgchange -a y|n"
-        """
-        return libguestfsmod.vg_activate_all (self._o, activate)
-
-    def vg_activate (self, activate, volgroups):
-        u"""This command activates or (if "activate" is false)
-        deactivates all logical volumes in the listed volume
-        groups "volgroups". If activated, then they are made
-        known to the kernel, ie. they appear as "/dev/mapper"
-        devices. If deactivated, then those devices disappear.
-        
-        This command is the same as running "vgchange -a y|n
-        volgroups..."
-        
-        Note that if "volgroups" is an empty list then all
-        volume groups are activated or deactivated.
-        """
-        return libguestfsmod.vg_activate (self._o, activate, volgroups)
-
-    def lvresize (self, device, mbytes):
-        u"""This resizes (expands or shrinks) an existing LVM
-        logical volume to "mbytes". When reducing, data in the
-        reduced part is lost.
-        """
-        return libguestfsmod.lvresize (self._o, device, mbytes)
-
-    def resize2fs (self, device):
-        u"""This resizes an ext2 or ext3 filesystem to match the
-        size of the underlying device.
-        
-        *Note:* It is sometimes required that you run
-        "g.e2fsck_f" on the "device" before calling this
-        command. For unknown reasons "resize2fs" sometimes gives
-        an error about this and sometimes not. In any case, it
-        is always safe to call "g.e2fsck_f" before calling this
-        function.
-        """
-        return libguestfsmod.resize2fs (self._o, device)
-
-    def find (self, directory):
-        u"""This command lists out all files and directories,
-        recursively, starting at "directory". It is essentially
-        equivalent to running the shell command "find directory
-        -print" but some post-processing happens on the output,
-        described below.
-        
-        This returns a list of strings *without any prefix*.
-        Thus if the directory structure was:
-        
-        /tmp/a
-        /tmp/b
-        /tmp/c/d
-        
-        then the returned list from "g.find" "/tmp" would be 4
-        elements:
-        
-        a
-        b
-        c
-        c/d
-        
-        If "directory" is not a directory, then this command
-        returns an error.
-        
-        The returned list is sorted.
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.find (self._o, directory)
-
-    def e2fsck_f (self, device):
-        u"""This runs "e2fsck -p -f device", ie. runs the ext2/ext3
-        filesystem checker on "device", noninteractively ("-p"),
-        even if the filesystem appears to be clean ("-f").
-        
-        This command is only needed because of "g.resize2fs"
-        (q.v.). Normally you should use "g.fsck".
-        """
-        return libguestfsmod.e2fsck_f (self._o, device)
-
-    def sleep (self, secs):
-        u"""Sleep for "secs" seconds.
-        """
-        return libguestfsmod.sleep (self._o, secs)
-
-    def ntfs_3g_probe (self, rw, device):
-        u"""This command runs the ntfs-3g.probe(8) command which
-        probes an NTFS "device" for mountability. (Not all NTFS
-        volumes can be mounted read-write, and some cannot be
-        mounted at all).
-        
-        "rw" is a boolean flag. Set it to true if you want to
-        test if the volume can be mounted read-write. Set it to
-        false if you want to test if the volume can be mounted
-        read-only.
-        
-        The return value is an integer which 0 if the operation
-        would succeed, or some non-zero value documented in the
-        ntfs-3g.probe(8) manual page.
-        """
-        return libguestfsmod.ntfs_3g_probe (self._o, rw, device)
-
-    def sh (self, command):
-        u"""This call runs a command from the guest filesystem via
-        the guest's "/bin/sh".
-        
-        This is like "g.command", but passes the command to:
-        
-        /bin/sh -c "command"
-        
-        Depending on the guest's shell, this usually results in
-        wildcards being expanded, shell expressions being
-        interpolated and so on.
-        
-        All the provisos about "g.command" apply to this call.
-        """
-        return libguestfsmod.sh (self._o, command)
-
-    def sh_lines (self, command):
-        u"""This is the same as "g.sh", but splits the result into a
-        list of lines.
-        
-        See also: "g.command_lines"
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.sh_lines (self._o, command)
-
-    def glob_expand (self, pattern):
-        u"""This command searches for all the pathnames matching
-        "pattern" according to the wildcard expansion rules used
-        by the shell.
-        
-        If no paths match, then this returns an empty list
-        (note: not an error).
-        
-        It is just a wrapper around the C glob(3) function with
-        flags "GLOB_MARK|GLOB_BRACE". See that manual page for
-        more details.
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.glob_expand (self._o, pattern)
-
-    def scrub_device (self, device):
-        u"""This command writes patterns over "device" to make data
-        retrieval more difficult.
-        
-        It is an interface to the scrub(1) program. See that
-        manual page for more details.
-        
-        This command is dangerous. Without careful use you can
-        easily destroy all your data.
-        """
-        return libguestfsmod.scrub_device (self._o, device)
-
-    def scrub_file (self, file):
-        u"""This command writes patterns over a file to make data
-        retrieval more difficult.
-        
-        The file is *removed* after scrubbing.
-        
-        It is an interface to the scrub(1) program. See that
-        manual page for more details.
-        """
-        return libguestfsmod.scrub_file (self._o, file)
-
-    def scrub_freespace (self, dir):
-        u"""This command creates the directory "dir" and then fills
-        it with files until the filesystem is full, and scrubs
-        the files as for "g.scrub_file", and deletes them. The
-        intention is to scrub any free space on the partition
-        containing "dir".
-        
-        It is an interface to the scrub(1) program. See that
-        manual page for more details.
-        """
-        return libguestfsmod.scrub_freespace (self._o, dir)
-
-    def mkdtemp (self, template):
-        u"""This command creates a temporary directory. The
-        "template" parameter should be a full pathname for the
-        temporary directory name with the final six characters
-        being "XXXXXX".
-        
-        For example: "/tmp/myprogXXXXXX" or
-        "/Temp/myprogXXXXXX", the second one being suitable for
-        Windows filesystems.
-        
-        The name of the temporary directory that was created is
-        returned.
-        
-        The temporary directory is created with mode 0700 and is
-        owned by root.
-        
-        The caller is responsible for deleting the temporary
-        directory and its contents after use.
-        
-        See also: mkdtemp(3)
-        """
-        return libguestfsmod.mkdtemp (self._o, template)
-
-    def wc_l (self, path):
-        u"""This command counts the lines in a file, using the "wc
-        -l" external command.
-        """
-        return libguestfsmod.wc_l (self._o, path)
-
-    def wc_w (self, path):
-        u"""This command counts the words in a file, using the "wc
-        -w" external command.
-        """
-        return libguestfsmod.wc_w (self._o, path)
-
-    def wc_c (self, path):
-        u"""This command counts the characters in a file, using the
-        "wc -c" external command.
-        """
-        return libguestfsmod.wc_c (self._o, path)
-
-    def head (self, path):
-        u"""This command returns up to the first 10 lines of a file
-        as a list of strings.
-        
-        This function returns a list of strings.
-        
-        Because of the message protocol, there is a transfer
-        limit of somewhere between 2MB and 4MB. To transfer
-        large files you should use FTP.
-        """
-        return libguestfsmod.head (self._o, path)
-
-    def head_n (self, nrlines, path):
-        u"""If the parameter "nrlines" is a positive number, this
-        returns the first "nrlines" lines of the file "path".
-        
-        If the parameter "nrlines" is a negative number, this
-        returns lines from the file "path", excluding the last
-        "nrlines" lines.
-        
-        If the parameter "nrlines" is zero, this returns an
-        empty list.
-        
-        This function returns a list of strings.
-        
-        Because of the message protocol, there is a transfer
-        limit of somewhere between 2MB and 4MB. To transfer
-        large files you should use FTP.
-        """
-        return libguestfsmod.head_n (self._o, nrlines, path)
-
-    def tail (self, path):
-        u"""This command returns up to the last 10 lines of a file
-        as a list of strings.
-        
-        This function returns a list of strings.
-        
-        Because of the message protocol, there is a transfer
-        limit of somewhere between 2MB and 4MB. To transfer
-        large files you should use FTP.
-        """
-        return libguestfsmod.tail (self._o, path)
-
-    def tail_n (self, nrlines, path):
-        u"""If the parameter "nrlines" is a positive number, this
-        returns the last "nrlines" lines of the file "path".
-        
-        If the parameter "nrlines" is a negative number, this
-        returns lines from the file "path", starting with the
-        "-nrlines"th line.
-        
-        If the parameter "nrlines" is zero, this returns an
-        empty list.
-        
-        This function returns a list of strings.
-        
-        Because of the message protocol, there is a transfer
-        limit of somewhere between 2MB and 4MB. To transfer
-        large files you should use FTP.
-        """
-        return libguestfsmod.tail_n (self._o, nrlines, path)
-
-    def df (self):
-        u"""This command runs the "df" command to report disk space
-        used.
-        
-        This command is mostly useful for interactive sessions.
-        It is *not* intended that you try to parse the output
-        string. Use "statvfs" from programs.
-        """
-        return libguestfsmod.df (self._o)
-
-    def df_h (self):
-        u"""This command runs the "df -h" command to report disk
-        space used in human-readable format.
-        
-        This command is mostly useful for interactive sessions.
-        It is *not* intended that you try to parse the output
-        string. Use "statvfs" from programs.
-        """
-        return libguestfsmod.df_h (self._o)
-
-    def du (self, path):
-        u"""This command runs the "du -s" command to estimate file
-        space usage for "path".
-        
-        "path" can be a file or a directory. If "path" is a
-        directory then the estimate includes the contents of the
-        directory and all subdirectories (recursively).
-        
-        The result is the estimated size in *kilobytes* (ie.
-        units of 1024 bytes).
-        """
-        return libguestfsmod.du (self._o, path)
-
-    def initrd_list (self, path):
-        u"""This command lists out files contained in an initrd.
-        
-        The files are listed without any initial "/" character.
-        The files are listed in the order they appear (not
-        necessarily alphabetical). Directory names are listed as
-        separate items.
-        
-        Old Linux kernels (2.4 and earlier) used a compressed
-        ext2 filesystem as initrd. We *only* support the newer
-        initramfs format (compressed cpio files).
-        
-        This function returns a list of strings.
-        """
-        return libguestfsmod.initrd_list (self._o, path)
-
-    def mount_loop (self, file, mountpoint):
-        u"""This command lets you mount "file" (a filesystem image
-        in a file) on a mount point. It is entirely equivalent
-        to the command "mount -o loop file mountpoint".
-        """
-        return libguestfsmod.mount_loop (self._o, file, mountpoint)
-
-    def mkswap (self, device):
-        u"""Create a swap partition on "device".
-        """
-        return libguestfsmod.mkswap (self._o, device)
-
-    def mkswap_L (self, label, device):
-        u"""Create a swap partition on "device" with label "label".
-        """
-        return libguestfsmod.mkswap_L (self._o, label, device)
-
-    def mkswap_U (self, uuid, device):
-        u"""Create a swap partition on "device" with UUID "uuid".
-        """
-        return libguestfsmod.mkswap_U (self._o, uuid, device)
-
-    def mknod (self, mode, devmajor, devminor, path):
-        u"""This call creates block or character special devices, or
-        named pipes (FIFOs).
-        
-        The "mode" parameter should be the mode, using the
-        standard constants. "devmajor" and "devminor" are the
-        device major and minor numbers, only used when creating
-        block and character special devices.
-        """
-        return libguestfsmod.mknod (self._o, mode, devmajor, devminor, path)
-
-    def mkfifo (self, mode, path):
-        u"""This call creates a FIFO (named pipe) called "path" with
-        mode "mode". It is just a convenient wrapper around
-        "g.mknod".
-        """
-        return libguestfsmod.mkfifo (self._o, mode, path)
-
-    def mknod_b (self, mode, devmajor, devminor, path):
-        u"""This call creates a block device node called "path" with
-        mode "mode" and device major/minor "devmajor" and
-        "devminor". It is just a convenient wrapper around
-        "g.mknod".
-        """
-        return libguestfsmod.mknod_b (self._o, mode, devmajor, devminor, path)
-
-    def mknod_c (self, mode, devmajor, devminor, path):
-        u"""This call creates a char device node called "path" with
-        mode "mode" and device major/minor "devmajor" and
-        "devminor". It is just a convenient wrapper around
-        "g.mknod".
-        """
-        return libguestfsmod.mknod_c (self._o, mode, devmajor, devminor, path)
-
-    def umask (self, mask):
-        u"""This function sets the mask used for creating new files
-        and device nodes to "mask & 0777".
-        
-        Typical umask values would be 022 which creates new
-        files with permissions like "-rw-r--r--" or
-        "-rwxr-xr-x", and 002 which creates new files with
-        permissions like "-rw-rw-r--" or "-rwxrwxr-x".
-        
-        The default umask is 022. This is important because it
-        means that directories and device nodes will be created
-        with 0644 or 0755 mode even if you specify 0777.
-        
-        See also umask(2), "g.mknod", "g.mkdir".
-        
-        This call returns the previous umask.
-        """
-        return libguestfsmod.umask (self._o, mask)
-
-    def readdir (self, dir):
-        u"""This returns the list of directory entries in directory
-        "dir".
-        
-        All entries in the directory are returned, including "."
-        and "..". The entries are *not* sorted, but returned in
-        the same order as the underlying filesystem.
-        
-        This function is primarily intended for use by programs.
-        To get a simple list of names, use "g.ls". To get a
-        printable directory for human consumption, use "g.ll".
-        
-        This function returns a list of directory entries. Each
-        directory entry is represented as a dictionary.
-        """
-        return libguestfsmod.readdir (self._o, dir)
-