office/gnucash: Updated for version 2.6.20.

Signed-off-by: David Spencer <idlemoor@slackbuilds.org>

8 files changed, 1395 insertions, 11 deletions

diff --git a/office/gnucash/README b/office/gnucash/README
index d79d07606c5b..d3d2451ed5f2 100644
--- a/office/gnucash/README
+++ b/office/gnucash/README
@@ -10,9 +10,13 @@ accurate reports.
 
 Pass OFX="yes" for OFX (USA) (requies libofx)
 Pass AQ="yes" to enable aqbanking (Germany) (requires aqbanking)
+Pass WITH_PYTHON="yes" to enable python bindings for report generation
 
 If you want the SQL database integration, you must first have libdbi
 and libdbi-drivers installed, and then pass the DBI="yes" flag.
 
 NOTE:  You must remove any previous installation of Gnucash before
-running this script, otherwise the build will fail. 
+running this script, otherwise the build will fail.
+
+EOL NOTE: According to the developers, this is the last release of the
+2.6.x series, with attention shifting to the 3.x series.
diff --git a/office/gnucash/doinst.sh b/office/gnucash/doinst.sh
index fffcfa3dd3d5..ea328e01fb26 100644
--- a/office/gnucash/doinst.sh
+++ b/office/gnucash/doinst.sh
@@ -18,6 +18,10 @@ if [ -x /usr/bin/update-desktop-database ]; then
   /usr/bin/update-desktop-database -q usr/share/applications >/dev/null 2>&1
 fi
 
+if [ -x /usr/bin/update-mime-database ]; then
+  /usr/bin/update-mime-database usr/share/mime >/dev/null 2>&1
+fi
+
 if [ -e usr/share/icons/hicolor/icon-theme.cache ]; then
   if [ -x /usr/bin/gtk-update-icon-cache ]; then
     /usr/bin/gtk-update-icon-cache -f usr/share/icons/hicolor >/dev/null 2>&1
diff --git a/office/gnucash/gnucash.SlackBuild b/office/gnucash/gnucash.SlackBuild
index d9b2f2e6a748..1d2fbb8a8c7a 100644
--- a/office/gnucash/gnucash.SlackBuild
+++ b/office/gnucash/gnucash.SlackBuild
@@ -24,7 +24,7 @@
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 PRGNAM=gnucash
-VERSION=${VERSION:-2.6.19}
+VERSION=${VERSION:-2.6.20}
 BUILD=${BUILD:-1}
 TAG=${TAG:-_SBo}
 
@@ -61,10 +61,16 @@ else
   LIBDIRSUFFIX=""
 fi
 
+# First, make sure a previous Gnucash installation is removed:
+if [ -e /usr/bin/gnucash ]; then
+  echo "A previous Gnucash installation has been found."
+  echo "Please remove it before running this script."
+  exit 1
+fi
+
 if [ "$DBI" = "yes" ]; then
   DBIARGS="--enable-dbi --with-dbi-dbd-dir=/usr/lib${LIBDIRSUFFIX}/dbd/ "
   echo " building with dbi enabled"
-  sleep 1
 else
   DBIARGS="--disable-dbi "
 fi
@@ -72,7 +78,6 @@ fi
 if [ "$OFX" = "yes" ]; then
   OFXBANKING="--enable-ofx"
   echo " building with OFX enabled"
-  sleep 1
 else
   OFXBANKING="--disable-ofx"
 fi
@@ -80,11 +85,17 @@ fi
 if [ "$AQ" = "yes" ]; then
   AQBANKING="--enable-aqbanking"
   echo " building with aqbanking enabled"
-  sleep 1
 else
   AQBANKING="--disable-aqbanking"
 fi
 
+if [ "$WITH_PYTHON" = "yes" ]; then
+  W_PYTHON="--enable-python"
+  echo " building with Python bindings enabled"
+else
+  W_PYTHON="--disable-python"
+fi
+
 set -e
 
 # First, make sure a previous Gnucash installation is removed:
@@ -94,13 +105,18 @@ if [ -e /usr/bin/gnucash ]; then
   exit 1
 fi
 
-
 rm -rf $PKG
 mkdir -p $TMP $PKG $OUTPUT
 cd $TMP
 rm -rf $PRGNAM-$VERSION
 tar xvf $CWD/$PRGNAM-$VERSION.tar.bz2
 cd $PRGNAM-$VERSION
+
+# Restore missing .py files lost from 2.6.19 to 2.6.20:
+if [ "$WITH_PYTHON" = "yes" ]; then
+  cp -nv $CWD/missing-py/* src/optional/python-bindings
+fi
+
 chown -R root:root .
 find -L . \
  \( -perm 777 -o -perm 775 -o -perm 750 -o -perm 711 -o -perm 555 \
@@ -118,7 +134,8 @@ CXXFLAGS="$SLKCFLAGS" \
   --infodir=/usr/info \
   --mandir=/usr/man \
   --docdir=/usr/doc/$PRGNAM-$VERSION \
-  --enable-python \
+  --enable-register2 \
+  $W_PYTHON \
   $OFXBANKING \
   $AQBANKING \
   --disable-schemas-compile \
@@ -151,4 +168,3 @@ cat $CWD/doinst.sh > $PKG/install/doinst.sh
 
 cd $PKG
 /sbin/makepkg -p -l y -c n $OUTPUT/$PRGNAM-$VERSION-$ARCH-$BUILD$TAG.${PKGTYPE:-tgz}
-
diff --git a/office/gnucash/gnucash.info b/office/gnucash/gnucash.info
index 66c088cf6f32..947e698a9545 100644
--- a/office/gnucash/gnucash.info
+++ b/office/gnucash/gnucash.info
@@ -1,8 +1,8 @@
 PRGNAM="gnucash"
-VERSION="2.6.19"
+VERSION="2.6.20"
 HOMEPAGE="http://www.gnucash.org/"
-DOWNLOAD="http://downloads.sourceforge.net/gnucash/gnucash-2.6.19.tar.bz2"
-MD5SUM="f7c6584b628f1e9baa9207c6fae6a850"
+DOWNLOAD="http://downloads.sourceforge.net/gnucash/gnucash-2.6.20.tar.bz2"
+MD5SUM="edec38fa225082b849f76cd440689fe2"
 DOWNLOAD_x86_64=""
 MD5SUM_x86_64=""
 REQUIRES="libgnomecanvas goffice0.8 webkitgtk"
diff --git a/office/gnucash/missing-py/__init__.py b/office/gnucash/missing-py/__init__.py
new file mode 100644
index 000000000000..3627eac4783f
--- /dev/null
+++ b/office/gnucash/missing-py/__init__.py
@@ -0,0 +1,11 @@
+# import all the symbols from gnucash_core, so basic gnucash stuff can be
+# loaded with:
+# >>> from gnucash import thingy
+# instead of
+# >>> from gnucash.gnucash_core import thingy
+from gnucash_core import *
+##  @file
+#   @brief helper file for the importing of gnucash
+#   @author Mark Jenkins, ParIT Worker Co-operative <mark@parit.ca>
+#   @author Jeff Green,   ParIT Worker Co-operative <jeff@parit.ca>
+#   @ingroup python_bindings
diff --git a/office/gnucash/missing-py/function_class.py b/office/gnucash/missing-py/function_class.py
new file mode 100644
index 000000000000..f628667a4f4f
--- /dev/null
+++ b/office/gnucash/missing-py/function_class.py
@@ -0,0 +1,227 @@
+# function_class.py -- Library for making python classes from a set
+#                      of functions. 
+#
+# Copyright (C) 2008 ParIT Worker Co-operative <paritinfo@parit.ca>
+# 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, contact:
+# Free Software Foundation           Voice:  +1-617-542-5942
+# 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652
+# Boston, MA  02110-1301,  USA       gnu@gnu.org
+#
+# @author Mark Jenkins, ParIT Worker Co-operative <mark@parit.ca>
+
+##  @file
+#   @brief Library for making python classes from a set of functions.
+#   @author Mark Jenkins, ParIT Worker Co-operative <mark@parit.ca>
+#   @author Jeff Green,   ParIT Worker Co-operative <jeff@parit.ca>
+#   @ingroup python_bindings
+
+INSTANCE_ARGUMENT = "instance"
+
+class ClassFromFunctions(object):
+    """Inherit this class to give yourself a python class that wraps a set of
+    functions that together constitute the methods of the class.
+
+    The method functions must all have as a first argument an object
+    holding the instance data. There must also be a function that
+    returns a new instance of the class, the constructor.
+
+    Your subclass must define
+    _module - The module where the method functions, including the
+    constructor can be found
+    _new_instance - The name of a function that serves as a constructor,
+    returning the instance data.
+
+    To access the instance data, use the read-only property instance.
+
+    To add some functions from _module as methods, call classmethods like
+    add_method and add_methods_with_prefix.
+    """
+    def __new__(cls, *args, **kargs):
+        # why reimpliment __new__? Because later on we're going to
+        # use new to avoid creating new instances when existing instances
+        # already exist with the same __instance value, or equivalent __instance
+        # values, where this is desirable...
+        return super(ClassFromFunctions, cls).__new__(cls)
+    
+    def __init__(self, *args, **kargs):
+        """Construct a new instance, using either the function
+        self._module[self._new_instance] or using existing instance
+        data. (specified with the keyword argument, instance)
+
+        Pass the arguments that should be passed on to
+        self._module[self._new_instance] . Any arguments of that
+        are instances of ClassFromFunctions will be switched with the instance
+        data. (by calling the .instance property)
+        """
+        if INSTANCE_ARGUMENT in kargs:
+            self.__instance = kargs[INSTANCE_ARGUMENT]
+        else:
+            self.__instance = getattr(self._module, self._new_instance)(
+                *process_list_convert_to_instance(args) )
+
+    def get_instance(self):
+        """Get the instance data.
+
+        You can also call the instance property
+        """
+        return self.__instance
+
+    instance = property(get_instance)
+
+    # CLASS METHODS
+
+    @classmethod
+    def add_method(cls, function_name, method_name):
+        """Add the function, method_name to this class as a method named name
+        """
+        def method_function(self, *meth_func_args):
+            return getattr(self._module, function_name)(
+                self.instance,
+                *process_list_convert_to_instance(meth_func_args) )
+        
+        setattr(cls, method_name, method_function)
+        setattr(method_function, "__name__", method_name)
+        return method_function
+
+    @classmethod
+    def ya_add_classmethod(cls, function_name, method_name):
+        """Add the function, method_name to this class as a classmethod named name
+        
+        Taken from function_class and slightly modified.
+        """
+        def method_function(self, *meth_func_args):
+            return getattr(self._module, function_name)(
+                self,
+                *process_list_convert_to_instance(meth_func_args) )
+        
+        setattr(cls, method_name, classmethod(method_function))
+        setattr(method_function, "__name__", method_name)
+        return method_function    
+
+    @classmethod
+    def ya_add_method(cls, function_name, method_name):
+        """Add the function, method_name to this class as a method named name
+        
+        Taken from function_class and slightly modified.
+        """
+        def method_function(self, *meth_func_args):
+            return getattr(self._module, function_name)(
+                self,
+                *process_list_convert_to_instance(meth_func_args) )
+        
+        setattr(cls, method_name, method_function)
+        setattr(method_function, "__name__", method_name)
+        return method_function
+
+    @classmethod
+    def add_methods_with_prefix(cls, prefix):
+        """Add a group of functions with the same prefix 
+        """
+        for function_name, function_value, after_prefix in \
+            extract_attributes_with_prefix(cls._module, prefix):
+                cls.add_method(function_name, after_prefix)
+    
+    @classmethod
+    def add_constructor_and_methods_with_prefix(cls, prefix, constructor):
+        """Add a group of functions with the same prefix, and set the
+        _new_instance attribute to prefix + constructor
+        """
+        cls.add_methods_with_prefix(prefix)
+        cls._new_instance = prefix + constructor
+
+    @classmethod
+    def decorate_functions(cls, decorator, *args):
+        for function_name in args:
+            setattr( cls, function_name,
+                     decorator( getattr(cls, function_name) ) )
+
+def method_function_returns_instance(method_function, cls):
+    """A function decorator that is used to decorate method functions that
+    return instance data, to return instances instead.
+
+    You can't use this decorator with @, because this function has a second
+    argument.
+    """
+    assert( 'instance' == INSTANCE_ARGUMENT )
+    def new_function(*args):
+        kargs = { INSTANCE_ARGUMENT : method_function(*args) }
+        if kargs['instance'] == None:
+            return None
+        else:
+            return cls( **kargs )
+    
+    return new_function
+
+def method_function_returns_instance_list(method_function, cls):
+    def new_function(*args):
+        return [ cls( **{INSTANCE_ARGUMENT: item} )
+                 for item in method_function(*args) ]
+    return new_function
+
+def methods_return_instance_lists(cls, function_dict):
+    for func_name, instance_name in function_dict.iteritems():
+        setattr(cls, func_name,
+                method_function_returns_instance_list(
+                getattr(cls, func_name), instance_name))
+
+def default_arguments_decorator(function, *args):
+    """Decorates a function to give it default, positional arguments
+
+    You can't use this decorator with @, because this function has more
+    than one argument.
+    """
+    def new_function(*function_args):
+        new_argset = list(function_args)
+        new_argset.extend( args[ len(function_args): ] )
+        return function( *new_argset )
+    return new_function
+    
+def return_instance_if_value_has_it(value):
+    """Return value.instance if value is an instance of ClassFromFunctions,
+    else return value
+    """
+    if isinstance(value, ClassFromFunctions):
+        return value.instance
+    else:
+        return value
+
+def process_list_convert_to_instance( value_list ):
+    """Return a list built from value_list, where if a value is in an instance
+    of ClassFromFunctions, we put value.instance in the list instead.
+
+    Things that are not instances of ClassFromFunctions are returned to
+    the new list unchanged.
+    """
+    return [ return_instance_if_value_has_it(value)
+             for value in value_list ]
+
+def extract_attributes_with_prefix(obj, prefix):
+    """Generator that iterates through the attributes of an object and
+    for any attribute that matches a prefix, this yields
+    the attribute name, the attribute value, and the text that appears
+    after the prefix in the name
+    """
+    for attr_name, attr_value in obj.__dict__.iteritems():
+        if attr_name.startswith(prefix):
+            after_prefix = attr_name[ len(prefix): ]
+            yield attr_name, attr_value, after_prefix
+
+def methods_return_instance(cls, function_dict):
+    """Iterates through a dictionary of function name strings and instance names
+    and sets the function to return the associated instance 
+    """
+    for func_name, instance_name in function_dict.iteritems():
+        setattr(cls, func_name, 
+            method_function_returns_instance( getattr(cls, func_name), instance_name))
+
diff --git a/office/gnucash/missing-py/gnucash_business.py b/office/gnucash/missing-py/gnucash_business.py
new file mode 100644
index 000000000000..a64162a74c1a
--- /dev/null
+++ b/office/gnucash/missing-py/gnucash_business.py
@@ -0,0 +1,370 @@
+# gnucash_business.py -- High level python wrapper classes for the business
+#                        parts of GnuCash
+#
+# Copyright (C) 2008,2010 ParIT Worker Co-operative <paritinfo@parit.ca>
+# 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, contact:
+# Free Software Foundation           Voice:  +1-617-542-5942
+# 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652
+# Boston, MA  02110-1301,  USA       gnu@gnu.org
+#
+# @author Mark Jenkins, ParIT Worker Co-operative <mark@parit.ca>
+# @author Jeff Green,   ParIT Worker Co-operative <jeff@parit.ca>
+##  @file
+#   @brief High level python wrapper classes for the business parts of GnuCash
+#   @author Mark Jenkins, ParIT Worker Co-operative <mark@parit.ca>
+#   @author Jeff Green,   ParIT Worker Co-operative <jeff@parit.ca>
+#   @ingroup python_bindings
+
+import gnucash_core_c
+
+from function_class import \
+     ClassFromFunctions, extract_attributes_with_prefix, \
+     default_arguments_decorator, method_function_returns_instance, \
+     methods_return_instance, methods_return_instance_lists
+
+from gnucash_core import \
+     GnuCashCoreClass, GncNumeric, GncCommodity, Transaction, \
+     Split, Book, GncLot, Account
+
+from gnucash_core_c import GNC_OWNER_CUSTOMER, GNC_OWNER_JOB, \
+    GNC_OWNER_EMPLOYEE, GNC_OWNER_VENDOR, \
+    GNC_PAYMENT_CASH, GNC_PAYMENT_CARD, \
+    GNC_DISC_PRETAX, GNC_DISC_SAMETIME, GNC_DISC_POSTTAX, \
+    GNC_TAXINCLUDED_YES, GNC_TAXINCLUDED_NO, GNC_TAXINCLUDED_USEGLOBAL, \
+    GNC_AMT_TYPE_VALUE, GNC_AMT_TYPE_PERCENT, GNC_ID_INVOICE
+
+import datetime
+
+class GnuCashBusinessEntity(GnuCashCoreClass):
+    def __init__(self, book=None, id=None, currency=None, name=None,
+                 instance=None):
+        if instance == None:
+            if book==None or id==None or currency==None:
+                raise Exception(
+                    "you must call GnuCashBusinessEntity.__init__ "
+                    "with either a book, id, and currency, or an existing "
+                    "low level swig proxy in the argument instance")
+            GnuCashCoreClass.__init__(self, book)
+            self.BeginEdit()
+            self.SetID(id)
+            self.SetCurrency(currency)
+            if name != None:
+                self.SetName(name)
+            self.CommitEdit()
+        else:
+            GnuCashCoreClass.__init__(self, instance=instance)
+
+class Customer(GnuCashBusinessEntity): pass
+                         
+class Employee(GnuCashBusinessEntity): pass
+
+class Vendor(GnuCashBusinessEntity): pass
+
+class Job(GnuCashBusinessEntity):
+    # override the superclass constructor, as Job doesn't require
+    # a currency but it does require an owner
+    def __init__(self, book=None, id=None, owner=None, name=None,
+                 instance=None):
+        if instance == None:
+            if book==None or id==None or owner==None:
+                raise Exception(
+                    "you must call Job.__init__ "
+                    "with either a book, id, and owner or an existing "
+                    "low level swig proxy in the argument instance")
+            GnuCashCoreClass.__init__(self, book)
+            self.SetID(id)
+            self.SetOwner(owner)
+            if name != None:
+                self.SetName(name)
+        else:
+            GnuCashCoreClass.__init__(self, instance=instance)    
+
+class Address(GnuCashCoreClass): pass
+    
+class BillTerm(GnuCashCoreClass): pass
+
+class TaxTable(GnuCashCoreClass):
+    def __init__(self, book=None, name=None, first_entry=None, instance=None):
+        if instance == None:
+            if book==None or name==None or first_entry==None:
+                raise Exception(
+                    "you must call TaxTable.__init__  with either a "
+                    "book, name, and first_entry, or an existing "
+                    "low level swig proxy in the argument instance")
+            GnuCashCoreClass.__init__(self, book)
+            self.SetName(name)
+            self.AddEntry(first_entry)
+        else:
+            GnuCashCoreClass.__init__(self, instance=instance)
+
+class TaxTableEntry(GnuCashCoreClass):
+    def __init__(self, account=None, percent=True, amount=None, instance=None):
+        """TaxTableEntry constructor
+        
+        You must provide an account, or be initizing this with an existing
+        swig proxy object via the instance keyword argument.
+        
+        You may also optionally set the percent keyword argument to False to get
+        a fixed value instead of percentage based tax (which is the default, or
+        when percent=True).
+        
+        The tax will be zero percent or zero unless you set the amount keyword
+        argument to a GncNumeric value as well.
+        """
+
+        if instance == None:
+            if account==None:
+                raise Exception(
+                    "you must call TaxTableEntry.__init__  with either a "
+                    "account or an existing "
+                    "low level swig proxy in the argument instance")
+            GnuCashCoreClass.__init__(self)
+            self.SetAccount(account)
+            if percent:
+                self.SetType(GNC_AMT_TYPE_PERCENT)
+            else:
+                self.SetType(GNC_AMT_TYPE_VALUE)
+            if amount != None:
+                self.SetAmount(amount)
+        else:
+            GnuCashCoreClass.__init__(self, instance=instance)        
+
+class Invoice(GnuCashCoreClass):
+    def __init__(self, book=None, id=None, currency=None, owner=None,
+                 date_opened=None, instance=None):
+        """Invoice Contstructor
+
+        You must provide a book, id, currency and owner
+        (Customer, Job, Employee, Vendor) or an existing swig proxy object
+        in the keyword argument instance.
+
+        Optionally, you may provide a date the invoice is opened on
+        (datetime.date or datetime.datetime), otherwise today's date is used.
+        """
+        if instance == None:
+            if book==None or id==None or currency==None or owner==None:
+                raise Exception(
+                    "you must call Invoice.__init__ "
+                    "with either a book, id, currency and owner, or an existing"
+                    "low level swig proxy in the argument instance")
+            GnuCashCoreClass.__init__(self, book)
+            self.BeginEdit()
+            self.SetID(id)
+            self.SetCurrency(currency)
+            self.SetOwner(owner)
+            if date_opened == None:
+                date_opened = datetime.date.today()
+            self.SetDateOpened(date_opened)
+            self.CommitEdit()
+        else:
+            GnuCashCoreClass.__init__(self, instance=instance)
+
+class Bill(Invoice):
+    pass
+
+def decorate_to_return_instance_instead_of_owner(dec_function):
+    def new_get_owner_function(self):
+        (owner_type, instance) = dec_function(self)
+        if owner_type == GNC_OWNER_CUSTOMER:
+            return Customer(instance=instance)
+        elif owner_type == GNC_OWNER_JOB:
+            return Job(instance=instance)
+        elif owner_type == GNC_OWNER_EMPLOYEE:
+            return Employee(instance=instance)
+        elif owner_type == GNC_OWNER_VENDOR:
+            return Vendor(instance=instance)
+        else:
+            return None
+    return new_get_owner_function
+
+class Entry(GnuCashCoreClass):
+    def __init__(self, book=None, invoice=None, date=None, instance=None):
+        """Invoice Entry constructor
+        
+        You must provide a book or be initizing this with an existing
+        swig proxy object via the instance keyword argument.
+
+        The optional invoice argument can be set to a Bill or Invoice
+        that you would like to associate the entry with. You might as well
+        assign one now, as an Entry can't exist without one, but you can
+        always use Invoice.AddEntry or Bill.AddEntry later on.
+
+        By default, the entry will be set to today's date unless you
+        override with the date argument.
+        """
+        if instance == None:
+            if book==None:
+                raise Exception(
+                    "you must call Entry.__init__  with either a "
+                    "book or an existing "
+                    "low level swig proxy in the argument instance")
+            GnuCashCoreClass.__init__(self, book)
+
+            if date == None:
+                date = datetime.date.today()
+            self.SetDate(date)
+            if invoice != None:
+                invoice.AddEntry(self)
+        else:
+
+            GnuCashCoreClass.__init__(self, instance=instance)
+
+    def test_type(self, invoice):
+        if invoice.GetTypeString() == "Invoice" and self.GetInvoice() == None:
+            raise Exception("Entry type error. Check that Entry type matches Invoice.")
+        if invoice.GetTypeString() == "Bill" and self.GetBill() == None:
+            raise Exception("Entry type error. Check that Entry type matches Bill.")
+
+
+# Owner
+GnuCashBusinessEntity.add_methods_with_prefix('gncOwner')
+
+owner_dict = {
+                    'GetCustomer' : Customer,
+                    'GetVendor' : Vendor,
+                    'GetEmployee' : Employee,
+                    'GetJob' : Job,
+                    'GetAddr' : Address,
+                    'GetCurrency' : GncCommodity,
+                    'GetEndOwner': GnuCashBusinessEntity,
+                    'GetBalanceInCurrency': GncNumeric,
+              }
+methods_return_instance(GnuCashBusinessEntity, owner_dict)
+
+methods_return_instance_lists(
+    GnuCashBusinessEntity, {
+        'GetCommoditiesList': GncCommodity
+    })
+
+# Customer
+Customer.add_constructor_and_methods_with_prefix('gncCustomer', 'Create')
+
+customer_dict = {
+                    'GetAddr' : Address,
+                    'GetShipAddr' : Address,
+                    'GetDiscount' : GncNumeric,
+                    'GetCredit' : GncNumeric,
+                    'GetTerms' : BillTerm,
+                    'GetCurrency' : GncCommodity,
+                    'GetTaxTable': TaxTable,
+                }
+methods_return_instance(Customer, customer_dict)
+
+# Employee
+Employee.add_constructor_and_methods_with_prefix('gncEmployee', 'Create')
+
+employee_dict = {
+                    'GetBook' : Book,
+                    'GetAddr' : Address,
+                    'GetWorkday' : GncNumeric,
+                    'GetRate' : GncNumeric,
+                    'GetCurrency' : GncCommodity
+                }
+methods_return_instance(Employee, employee_dict)
+
+# Vendor
+Vendor.add_constructor_and_methods_with_prefix('gncVendor', 'Create')
+
+vendor_dict =   {
+                    'GetAddr' : Address,
+                    'GetTerms' : BillTerm,
+                    'GetCurrency' : GncCommodity,
+                    'GetTaxTable': TaxTable,
+                }
+methods_return_instance(Vendor, vendor_dict)
+
+# Job
+Job.add_constructor_and_methods_with_prefix('gncJob', 'Create')
+Job.decorate_functions(
+    decorate_to_return_instance_instead_of_owner,
+    'GetOwner')
+
+# Address
+Address.add_constructor_and_methods_with_prefix('gncAddress', 'Create')
+
+# BillTerm
+BillTerm.add_constructor_and_methods_with_prefix('gncBillTerm', 'Create')
+
+billterm_dict = {
+                    'LookupByName' : BillTerm,
+                    'GetDiscount' : GncNumeric,
+                    'GetParent' : BillTerm,
+                    'ReturnChild' : BillTerm
+                }
+methods_return_instance(BillTerm, billterm_dict)
+
+# TaxTable
+TaxTable.add_constructor_and_methods_with_prefix('gncTaxTable', 'Create')
+
+taxtable_dict = {
+                    'GetParent': TaxTable,
+                }
+methods_return_instance(TaxTable, taxtable_dict)
+
+# TaxTableEntry
+TaxTableEntry.add_constructor_and_methods_with_prefix(
+    'gncTaxTableEntry', 'Create')
+
+taxtableentry_dict = {
+                         'GetAccount': Account,
+                         'GetAmount': GncNumeric,
+                     }
+
+# Invoice
+Invoice.add_constructor_and_methods_with_prefix('gncInvoice', 'Create')
+methods_return_instance_lists(
+    Invoice, { 'GetEntries': Entry })
+
+# Bill
+Bill.add_methods_with_prefix('gncBill')
+
+invoice_dict = {
+                   'GetTerms': BillTerm,
+                   'GetCurrency': GncCommodity,
+                   'GetToChargeAmount': GncNumeric,
+                   'GetPostedLot': GncLot,
+                   'GetPostedTxn': Transaction,
+                   'GetPostedAcc': Account,
+                   'GetTotal': GncNumeric,
+                   'GetTotalOf': GncNumeric,
+                   'GetTotalSubtotal': GncNumeric,
+                   'GetTotalTax': GncNumeric,
+                   'PostToAccount': Transaction,
+                   'GetBook': Book,
+               }
+methods_return_instance(Invoice, invoice_dict)
+Invoice.decorate_functions(
+    decorate_to_return_instance_instead_of_owner,
+    'GetOwner', 'GetBillTo')
+
+# Entry
+Entry.add_constructor_and_methods_with_prefix('gncEntry', 'Create')
+
+entry_dict = {
+                 'GetQuantity': GncNumeric,
+                 'GetInvAccount': Account,
+                 'GetInvPrice': GncNumeric,
+                 'GetInvDiscount': GncNumeric,
+                 'GetInvTaxTable': TaxTable,
+                 'GetBillAccount': Account,
+                 'GetBillPrice': GncNumeric,
+                 'GetBillTaxTable': TaxTable,
+                 'Copy': Entry,
+                 'GetInvoice': Invoice,
+                 'GetBill': Invoice
+             }
+methods_return_instance(Entry, entry_dict)             
+Entry.decorate_functions(
+    decorate_to_return_instance_instead_of_owner,
+    'GetBillTo' )
diff --git a/office/gnucash/missing-py/gnucash_core.py b/office/gnucash/missing-py/gnucash_core.py
new file mode 100644
index 000000000000..578e800ed745
--- /dev/null
+++ b/office/gnucash/missing-py/gnucash_core.py
@@ -0,0 +1,752 @@
+# gnucash_core.py -- High level python wrapper classes for the core parts
+#                    of GnuCash
+#
+# Copyright (C) 2008 ParIT Worker Co-operative <paritinfo@parit.ca>
+# 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, contact:
+# Free Software Foundation           Voice:  +1-617-542-5942
+# 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652
+# Boston, MA  02110-1301,  USA       gnu@gnu.org
+#
+# @author Mark Jenkins, ParIT Worker Co-operative <mark@parit.ca>
+# @author Jeff Green,   ParIT Worker Co-operative <jeff@parit.ca>
+
+# The following is for doxygen
+## @file
+#  @brief High level python wrapper classes for the core parts of GnuCash
+#  @author Mark Jenkins, ParIT Worker Co-operative <mark@parit.ca>
+#  @author Jeff Green,   ParIT Worker Co-operative <jeff@parit.ca>
+#  @ingroup python_bindings
+
+import gnucash_core_c
+
+from function_class import \
+     ClassFromFunctions, extract_attributes_with_prefix, \
+     default_arguments_decorator, method_function_returns_instance, \
+     methods_return_instance, process_list_convert_to_instance, \
+     method_function_returns_instance_list, methods_return_instance_lists
+
+from gnucash_core_c import gncInvoiceLookup, gncInvoiceGetInvoiceFromTxn, \
+    gncInvoiceGetInvoiceFromLot, gncEntryLookup, gncInvoiceLookup, \
+    gncCustomerLookup, gncVendorLookup, gncJobLookup, gncEmployeeLookup, \
+    gncTaxTableLookup, gncTaxTableLookupByName, gnc_search_invoice_on_id, \
+    gnc_search_customer_on_id, gnc_search_bill_on_id , gnc_search_vendor_on_id, \
+    gncInvoiceNextID, gncCustomerNextID, gncTaxTableGetTables, gncVendorNextID
+
+class GnuCashCoreClass(ClassFromFunctions):
+    _module = gnucash_core_c
+
+    def do_lookup_create_oo_instance(self, lookup_function, cls, *args):
+        thing = lookup_function(self.get_instance(), *args)
+        if thing != None:
+            thing = cls(instance=thing)
+        return thing
+
+
+class GnuCashBackendException(Exception):
+    def __init__(self, msg, errors):
+        Exception.__init__(self, msg)
+        self.errors = errors
+
+class Session(GnuCashCoreClass):
+    """A GnuCash book editing session
+
+    To commit changes to the session you may need to call save,
+    (this is always the case with the file backend).
+
+    When you're down with a session you may need to call end()
+
+    Every Session has a Book in the book attribute, which you'll definitely
+    be interested in, as every GnuCash entity (Transaction, Split, Vendor,
+    Invoice..) is associated with a particular book where it is stored.
+    """
+
+    def __init__(self, book_uri=None, ignore_lock=False, is_new=False,
+                 force_new= False):
+        """A convenient constructor that allows you to specify a book URI,
+        begin the session, and load the book.
+
+        This can give you the power of calling
+        qof_session_new, qof_session_begin, and qof_session_load all in one!
+
+        book_uri can be None to skip the calls to qof_session_begin and
+        qof_session_load, or it can be a string like "file:/test.xac"
+
+        qof_session_load is only called if is_new is set to False
+
+        is_new is passed to qof_session_begin as the argument create,
+        and force_new as the argument force. Is_new will create a new
+        database or file; force will force creation even if it will
+        destroy an existing dataset.
+
+        ignore_lock is passed to qof_session_begin's argument of the
+        same name and is used to break an existing lock on a dataset.
+
+
+
+        This function can raise a GnuCashBackendException. If it does,
+        you don't need to cleanup and call end() and destroy(), that is handled
+        for you, and the exception is raised.
+        """
+        GnuCashCoreClass.__init__(self)
+        if book_uri is not None:
+            try:
+                self.begin(book_uri, ignore_lock, is_new, force_new)
+                # Take care of backend inconsistency
+                # New xml file can't be loaded, new sql store
+                # has to be loaded before it can be altered
+                # Any existing store obviously has to be loaded
+                # More background: https://bugzilla.gnome.org/show_bug.cgi?id=726891
+                if book_uri[:3] != "xml" or not is_new:
+                    self.load()
+            except GnuCashBackendException, backend_exception:
+                self.end()
+                self.destroy()
+                raise
+
+    def raise_backend_errors(self, called_function="qof_session function"):
+        """Raises a GnuCashBackendException if there are outstanding
+        QOF_BACKEND errors.
+
+        set called_function to name the function that was last called
+        """
+        errors = self.pop_all_errors()
+        if errors != ():
+            raise GnuCashBackendException(
+                "call to %s resulted in the "
+                "following errors, %s" % (called_function, backend_error_dict[errors[0]]),
+                errors )
+
+    def generate_errors(self):
+        """A generator that yields any outstanding QofBackend errors
+        """
+        while self.get_error() is not ERR_BACKEND_NO_ERR:
+            error = self.pop_error()
+            yield error
+
+    def pop_all_errors(self):
+        """Returns any accumulated qof backend errors as a tuple
+        """
+        return tuple( self.generate_errors() )
+
+    # STATIC METHODS
+    @staticmethod
+    def raise_backend_errors_after_call(function):
+        """A function decorator that results in a call to
+        raise_backend_errors after execution.
+        """
+        def new_function(self, *args):
+            return_value = function(self, *args)
+            self.raise_backend_errors(function.__name__)
+            return return_value
+        return new_function
+
+class Book(GnuCashCoreClass):
+    """A Book encapsulates all of the GnuCash data, it is the place where
+    all GnuCash entities (Transaction, Split, Vendor, Invoice...), are
+    stored. You'll notice that all of the constructors for those entities
+    need a book to be associated with.
+
+    The most common way to get a book is through the book property in the
+    Session class, that is, create a session that connects to some storage,
+    such as through 'my_session = Session('file:my_books.xac')', and access
+    the book via the book property, 'my_session.book'
+
+    If you would like to create a Book without any backing storage, call the
+    Book constructor without any parameters, 'Book()'. You can later merge
+    such a book into a book with actual store by using merge_init.
+
+    Methods of interest
+    get_root_account -- Returns the root level Account
+    get_table -- Returns a commodity lookup table, of type GncCommodityTable
+    """
+    def InvoiceLookup(self, guid):
+        from gnucash_business import Invoice
+        return self.do_lookup_create_oo_instance(
+            gncInvoiceLookup, Invoice, guid.get_instance() )
+
+    def EntryLookup(self, guid):
+        from gnucash_business import Entr
+        return self.do_lookup_create_oo_instance(
+            gncEntryLookup, Entry, guid.get_instance() )
+
+    def CustomerLookup(self, guid):
+        from gnucash_business import Customer
+        return self.do_lookup_create_oo_instance(
+            gncCustomerLookup, Customer, guid.get_instance())
+
+    def JobLookup(self, guid):
+        from gnucash_business import Job
+        return self.do_lookup_create_oo_instance(
+            gncJobLookup, Job, guid.get_instance() )
+
+    def VendorLookup(self, guid):
+        from gnucash_business import Vendor
+        return self.do_lookup_create_oo_instance(
+            gncVendorLookup, Vendor, guid.get_instance() )
+
+    def EmployeeLookup(self, guid):
+        from gnucash_business import Employee
+        return self.do_lookup_create_oo_instance(
+            gncEmployeeLookup, Employee, guid.get_instance() )
+
+    def TaxTableLookup(self, guid):
+        from gnucash_business import TaxTable
+        return self.do_lookup_create_oo_instance(
+            gncTaxTableLookup, TaxTable, guid.get_instance() )
+
+    def TaxTableLookupByName(self, name):
+        from gnucash_business import TaxTable
+        return self.do_lookup_create_oo_instance(
+            gncTaxTableLookupByName, TaxTable, name)
+
+    def TaxTableGetTables(self):
+        from gnucash_business import TaxTable
+        return [ TaxTable(instance=item) for item in gncTaxTableGetTables(self.instance) ]
+
+    def BillLoookupByID(self, id):
+        from gnucash_business import Bill
+        return self.do_lookup_create_oo_instance(
+            gnc_search_bill_on_id, Bill, id)
+
+    def InvoiceLookupByID(self, id):
+        from gnucash_business import Invoice
+        return self.do_lookup_create_oo_instance(
+            gnc_search_invoice_on_id, Invoice, id)
+
+    def CustomerLookupByID(self, id):
+        from gnucash_business import Customer
+        return self.do_lookup_create_oo_instance(
+            gnc_search_customer_on_id, Customer, id)
+
+    def VendorLookupByID(self, id):
+        from gnucash_business import Vendor
+        return self.do_lookup_create_oo_instance(
+            gnc_search_vendor_on_id, Vendor, id)
+            
+    def InvoiceNextID(self, customer):
+      ''' Return the next invoice ID. 
+      This works but I'm not entirely happy with it.  FIX ME'''
+      from gnucash.gnucash_core_c import gncInvoiceNextID
+      return gncInvoiceNextID(self.get_instance(),customer.GetEndOwner().get_instance()[1])
+      
+    def BillNextID(self, vendor):
+      ''' Return the next Bill ID. '''
+      from gnucash.gnucash_core_c import gncInvoiceNextID
+      return gncInvoiceNextID(self.get_instance(),vendor.GetEndOwner().get_instance()[1])
+
+    def CustomerNextID(self):
+      ''' Return the next Customer ID. '''
+      from gnucash.gnucash_core_c import gncCustomerNextID
+      return gncCustomerNextID(self.get_instance())
+    
+    def VendorNextID(self):
+      ''' Return the next Vendor ID. '''
+      from gnucash.gnucash_core_c import gncVendorNextID
+      return gncVendorNextID(self.get_instance())
+
+class GncNumeric(GnuCashCoreClass):
+    """Object used by GnuCash to store all numbers. Always consists of a
+    numerator and denominator.
+
+    The constants GNC_DENOM_AUTO,
+    GNC_HOW_RND_FLOOR, GNC_HOW_RND_CEIL, GNC_HOW_RND_TRUNC,
+    GNC_HOW_RND_PROMOTE, GNC_HOW_RND_ROUND_HALF_DOWN,
+    GNC_HOW_RND_ROUND_HALF_UP, GNC_HOW_RND_ROUND, GNC_HOW_RND_NEVER,
+    GNC_HOW_DENOM_EXACT, GNC_HOW_DENOM_REDUCE, GNC_HOW_DENOM_LCD,
+    and GNC_HOW_DENOM_FIXED are available for arithmetic
+    functions like GncNumeric.add
+
+    Look at gnc-numeric.h to see how to use these
+    """
+
+    def __init__(self, num=0, denom=1, **kargs):
+        """Constructor that allows you to set the numerator and denominator or
+        leave them blank with a default value of 0 (not a good idea since there
+        is currently no way to alter the value after instantiation)
+        """
+        GnuCashCoreClass.__init__(self, num, denom, **kargs)
+        #if INSTANCE_ARG in kargs:
+        #    GnuCashCoreClass.__init__(**kargs)
+        #else:
+        #    self.set_denom(denom) # currently undefined
+        #    self.set_num(num)     # currently undefined
+
+    def __unicode__(self):
+        """Returns a human readable numeric value string as UTF8."""
+        if self.denom() == 0:
+            return "Division by zero"
+        else:
+            value_float = self.to_double() 
+            value_str   = u"{0:.{1}f}".format(value_float,2) ## The second argument is the precision. It would be nice to be able to make it configurable.
+            return value_str
+
+    def __str__(self):
+        """returns a human readable numeric value string as bytes."""
+        return unicode(self).encode('utf-8')
+
+class GncPrice(GnuCashCoreClass):
+    '''
+    Each priceEach price in the database represents an "instantaneous"
+    quote for a given commodity with respect to another commodity.
+    For example, a given price might represent the value of LNUX in USD on 2001-02-03.
+
+    Fields:
+      * commodity: the item being priced.
+      * currency: the denomination of the value of the item being priced.
+      * value: the value of the item being priced.
+      * time: the time the price was valid.
+      * source: a string describing the source of the quote. These strings will be something like this:
+      "Finance::Quote", "user:misc", "user:foo", etc. If the quote came from a user, as a matter of policy,
+      you *must* prefix the string you give with "user:". For now, the only other reserved values are
+      "Finance::Quote" and "old-file-import". Any string used must be added to the source_list array in
+      dialog-price-edit-db.c so that it can be properly translated. (There are unfortunately many strings
+      in users' databases, so this string must be translated on output instead of always being used in untranslated form).
+      * type: the type of quote - types possible right now are bid, ask, last, nav, and
+      unknown.Each price in the database represents an "instantaneous" quote for a given
+      commodity with respect to another commodity.
+      For example, a given price might represent the value of LNUX in USD on 2001-02-03.
+
+      See also http://code.gnucash.org/docs/head/group__Price.html
+    '''
+    pass
+GncPrice.add_methods_with_prefix('gnc_price_')
+
+
+class GncPriceDB(GnuCashCoreClass):
+    '''
+    a simple price database for gnucash.
+    The PriceDB is intended to be a database of price quotes, or more specifically,
+    a database of GNCPrices. For the time being, it is still a fairly simple
+    database supporting only fairly simple queries. It is expected that new
+    queries will be added as needed, and that there is some advantage to delaying
+    complex queries for now in the hope that we get a real DB implementation
+    before they're really needed.
+
+    Every QofBook contains a GNCPriceDB, accessible via gnc_pricedb_get_db.
+
+    Definition in file gnc-pricedb.h.
+    See also http://code.gnucash.org/docs/head/gnc-pricedb_8h.html
+    '''
+
+GncPriceDB.add_methods_with_prefix('gnc_pricedb_')
+PriceDB_dict =  {
+                'lookup_latest' : GncPrice,
+                'lookup_nearest_in_time' : GncPrice,
+                'lookup_latest_before' : GncPrice,
+                'convert_balance_latest_price' : GncNumeric,
+                'convert_balance_nearest_price' : GncNumeric,
+                }
+methods_return_instance(GncPriceDB,PriceDB_dict)
+GncPriceDB.get_prices = method_function_returns_instance_list(
+    GncPriceDB.get_prices, GncPrice )
+
+
+class GncCommodity(GnuCashCoreClass): pass
+
+class GncCommodityTable(GnuCashCoreClass):
+    """A CommodityTable provides a way to store and lookup commodities.
+    Commodities are primarily currencies, but other tradable things such as
+    stocks, mutual funds, and material substances are possible.
+
+    Users of this library should not create their own CommodityTable, instead
+    the get_table method from the Book class should be used.
+
+    This table is automatically populated with the GnuCash default commodity's
+    which includes most of the world's currencies.
+    """
+
+    pass
+
+class GncCommodityNamespace(GnuCashCoreClass):
+    pass
+
+class GncLot(GnuCashCoreClass):
+    def GetInvoiceFromLot(self):
+        from gnucash_business import Invoice
+        return self.do_lookup_create_oo_instance(
+            gncInvoiceGetInvoiceFromLot, Invoice )
+
+class Transaction(GnuCashCoreClass):
+    """A GnuCash Transaction
+
+    Consists of at least one (generally two) splits to represent a transaction
+    between two accounts.
+
+
+    Has a GetImbalance() method that returns a list of all the imbalanced
+    currencies. Each list item is a two element tuple, the first element is
+    the imbalanced commodity, the second element is the value.
+
+    Warning, the commodity.get_instance() value can be None when there
+    is no currency set for the transaction.
+    """
+    _new_instance = 'xaccMallocTransaction'
+    def GetNthSplit(self, n):
+        return self.GetSplitList().pop(n)
+
+    def GetInvoiceFromTxn(self):
+        from gnucash_business import Transaction
+        return self.do_lookup_create_oo_instance(
+            gncInvoiceGetInvoiceFromTxn, Transaction )
+
+def decorate_monetary_list_returning_function(orig_function):
+    def new_function(self):
+        # warning, item.commodity has been shown to be None
+        # when the transaction doesn't have a currency
+        return [(GncCommodity(instance=item.commodity),
+                 GncNumeric(instance=item.value))
+                for item in orig_function(self) ]
+    return new_function
+
+class Split(GnuCashCoreClass):
+    """A GnuCash Split
+
+    The most basic representation of a movement of currency from one account to
+    another.
+    """
+    _new_instance = 'xaccMallocSplit'
+
+class Account(GnuCashCoreClass):
+    """A GnuCash Account.
+
+    A fundamental entity in accounting, an Account provides representation
+    for a financial object, such as a ACCT_TYPE_BANK account, an
+    ACCT_TYPE_ASSET (like a building),
+    a ACCT_TYPE_LIABILITY (such as a bank loan), a summary of some type of
+    ACCT_TYPE_EXPENSE, or a summary of some source of ACCT_TYPE_INCOME .
+
+    The words in upper case are the constants that GnuCash and this library uses
+    to describe account type. Here is the full list:
+    ACCT_TYPE_ASSET, ACCT_TYPE_BANK, ACCT_TYPE_CASH, ACCT_TYPE_CHECKING, \
+    ACCT_TYPE_CREDIT, ACCT_TYPE_EQUITY, ACCT_TYPE_EXPENSE, ACCT_TYPE_INCOME, \
+    ACCT_TYPE_LIABILITY, ACCT_TYPE_MUTUAL, ACCT_TYPE_PAYABLE, \
+    ACCT_TYPE_RECEIVABLE, ACCT_TYPE_STOCK, ACCT_TYPE_ROOT, ACCT_TYPE_TRADING
+
+    These are not strings, they are attributes you can import from this
+    module
+    """
+    _new_instance = 'xaccMallocAccount'
+
+class GUID(GnuCashCoreClass):
+    _new_instance = 'guid_new_return'
+
+# Session
+Session.add_constructor_and_methods_with_prefix('qof_session_', 'new')
+
+def one_arg_default_none(function):
+    return default_arguments_decorator(function, None, None)
+Session.decorate_functions(one_arg_default_none, "load", "save")
+
+Session.decorate_functions( Session.raise_backend_errors_after_call,
+                            "begin", "load", "save", "end")
+Session.get_book = method_function_returns_instance(
+    Session.get_book, Book )
+
+Session.book = property( Session.get_book )
+
+# import all of the session backend error codes into this module
+this_module_dict = globals()
+for error_name, error_value, error_name_after_prefix in \
+    extract_attributes_with_prefix(gnucash_core_c, 'ERR_'):
+    this_module_dict[ error_name ] = error_value
+
+#backend error codes used for reverse lookup
+backend_error_dict = {}
+for error_name, error_value, error_name_after_prefix in \
+    extract_attributes_with_prefix(gnucash_core_c, 'ERR_'):
+    backend_error_dict[ error_value ] = error_name
+
+# GncNumeric denominator computation schemes
+# Used for the denom argument in arithmetic functions like GncNumeric.add
+from gnucash.gnucash_core_c import GNC_DENOM_AUTO
+
+# GncNumeric rounding instructions
+# used for the how argument in arithmetic functions like GncNumeric.add
+from gnucash.gnucash_core_c import \
+    GNC_HOW_RND_FLOOR, GNC_HOW_RND_CEIL, GNC_HOW_RND_TRUNC, \
+    GNC_HOW_RND_PROMOTE, GNC_HOW_RND_ROUND_HALF_DOWN, \
+    GNC_HOW_RND_ROUND_HALF_UP, GNC_HOW_RND_ROUND, GNC_HOW_RND_NEVER
+
+# GncNumeric denominator types
+# used for the how argument in arithmetic functions like GncNumeric.add
+from gnucash.gnucash_core_c import \
+    GNC_HOW_DENOM_EXACT, GNC_HOW_DENOM_REDUCE, GNC_HOW_DENOM_LCD, \
+    GNC_HOW_DENOM_FIXED
+
+# import account types
+from gnucash.gnucash_core_c import \
+    ACCT_TYPE_ASSET, ACCT_TYPE_BANK, ACCT_TYPE_CASH, ACCT_TYPE_CHECKING, \
+    ACCT_TYPE_CREDIT, ACCT_TYPE_EQUITY, ACCT_TYPE_EXPENSE, ACCT_TYPE_INCOME, \
+    ACCT_TYPE_LIABILITY, ACCT_TYPE_MUTUAL, ACCT_TYPE_PAYABLE, \
+    ACCT_TYPE_RECEIVABLE, ACCT_TYPE_STOCK, ACCT_TYPE_ROOT, ACCT_TYPE_TRADING
+
+#Book
+Book.add_constructor_and_methods_with_prefix('qof_book_', 'new')
+Book.add_method('gnc_book_get_root_account', 'get_root_account')
+Book.add_method('gnc_book_set_root_account', 'set_root_account')
+Book.add_method('gnc_commodity_table_get_table', 'get_table')
+Book.add_method('gnc_pricedb_get_db', 'get_price_db')
+Book.add_method('qof_book_increment_and_format_counter', 'increment_and_format_counter')
+
+#Functions that return Account
+Book.get_root_account = method_function_returns_instance(
+    Book.get_root_account, Account )
+#Functions that return GncCommodityTable
+Book.get_table = method_function_returns_instance(
+    Book.get_table, GncCommodityTable )
+#Functions that return GNCPriceDB
+Book.get_price_db = method_function_returns_instance(
+    Book.get_price_db, GncPriceDB)
+
+# GncNumeric
+GncNumeric.add_constructor_and_methods_with_prefix('gnc_numeric_', 'create')
+
+gncnumeric_dict =   {
+                        'same' : GncNumeric,
+                        'add' : GncNumeric,
+                        'sub' : GncNumeric,
+                        'mul' : GncNumeric,
+                        'div' : GncNumeric,
+                        'neg' : GncNumeric,
+                        'abs' : GncNumeric,
+                        'add_fixed' : GncNumeric,
+                        'sub_fixed' : GncNumeric,
+                        'add_with_error' : GncNumeric,
+                        'sub_with_error' : GncNumeric,
+                        'mul_with_error' : GncNumeric,
+                        'div_with_error' : GncNumeric,
+                        'convert' : GncNumeric,
+                        'reduce' : GncNumeric
+                    }
+methods_return_instance(GncNumeric, gncnumeric_dict)
+
+# GncCommodity
+GncCommodity.add_constructor_and_methods_with_prefix('gnc_commodity_', 'new')
+#Functions that return GncCommodity
+GncCommodity.clone = method_function_returns_instance(
+    GncCommodity.clone, GncCommodity )
+
+# GncCommodityTable
+GncCommodityTable.add_methods_with_prefix('gnc_commodity_table_')
+commoditytable_dict =   {
+                            'lookup' : GncCommodity,
+                            'lookup_unique' : GncCommodity,
+                            'find_full' : GncCommodity,
+                            'insert' : GncCommodity,
+                            'add_namespace': GncCommodityNamespace,
+                            'find_namespace': GncCommodityNamespace,
+                        }
+methods_return_instance(GncCommodityTable, commoditytable_dict)
+
+methods_return_instance_lists(
+    GncCommodityTable, { 'get_namespaces': GncCommodityNamespace,
+                         'get_namespaces_list': GncCommodityNamespace,
+                         'get_commodities': GncCommodity,
+                         'get_quotable_commodities': GncCommodity,
+                         
+                       } )
+
+# GncCommodityNamespace
+GncCommodityNamespace.add_methods_with_prefix('gnc_commodity_namespace_')
+GncCommodityNamespace.get_commodity_list = \
+    method_function_returns_instance_list(
+    GncCommodityNamespace.get_commodity_list, GncCommodity )
+
+# GncLot
+GncLot.add_constructor_and_methods_with_prefix('gnc_lot_', 'new')
+
+gnclot_dict =   {
+                    'get_account' : Account,
+                    'get_book' : Book,
+                    'get_earliest_split' : Split,
+                    'get_latest_split' : Split,
+                    'get_balance' : GncNumeric,
+                    'lookup' : GncLot,
+                    'make_default' : GncLot
+                }
+methods_return_instance(GncLot, gnclot_dict)
+
+# Transaction
+Transaction.add_methods_with_prefix('xaccTrans')
+Transaction.add_method('gncTransGetGUID', 'GetGUID');
+
+trans_dict =    {
+                    'GetSplit': Split,
+                    'FindSplitByAccount': Split,
+                    'Clone': Transaction,
+                    'Reverse': Transaction,
+                    'GetReversedBy': Transaction,
+                    'GetImbalanceValue': GncNumeric,
+                    'GetAccountValue': GncNumeric,
+                    'GetAccountAmount': GncNumeric,
+                    'GetAccountConvRate': GncNumeric,
+                    'GetAccountBalance': GncNumeric,
+                    'GetCurrency': GncCommodity,
+                    'GetGUID': GUID
+                }
+ 
+methods_return_instance(Transaction, trans_dict)
+methods_return_instance_lists(
+    Transaction, { 'GetSplitList': Split,
+                       })
+Transaction.decorate_functions(
+    decorate_monetary_list_returning_function, 'GetImbalance')
+
+# Split
+Split.add_methods_with_prefix('xaccSplit')
+Split.add_method('gncSplitGetGUID', 'GetGUID');
+
+split_dict =    {
+                    'GetBook': Book,
+                    'GetAccount': Account,
+                    'GetParent': Transaction,
+                    'Lookup': Split,
+                    'GetOtherSplit': Split,
+                    'GetAmount': GncNumeric,
+                    'GetValue': GncNumeric,
+                    'GetSharePrice': GncNumeric,
+                    'ConvertAmount': GncNumeric,
+                    'GetBaseValue': GncNumeric,
+                    'GetBalance': GncNumeric,
+                    'GetClearedBalance': GncNumeric,
+                    'GetReconciledBalance': GncNumeric,
+                    'VoidFormerAmount': GncNumeric,
+                    'VoidFormerValue': GncNumeric,
+                    'GetGUID': GUID
+                }
+methods_return_instance(Split, split_dict)
+
+Split.account = property( Split.GetAccount, Split.SetAccount )
+Split.parent = property( Split.GetParent, Split.SetParent )
+
+# Account
+Account.add_methods_with_prefix('xaccAccount')
+Account.add_methods_with_prefix('gnc_account_')
+Account.add_method('gncAccountGetGUID', 'GetGUID');
+
+account_dict =  {
+                    'get_book' : Book,
+                    'Lookup' : Account,
+                    'get_parent' : Account,
+                    'get_root' : Account,
+                    'nth_child' : Account,
+                    'lookup_by_code' : Account,
+                    'lookup_by_name' : Account,
+                    'lookup_by_full_name' : Account,
+                    'FindTransByDesc' : Transaction,
+                    'FindSplitByDesc' : Split,
+                    'GetBalance' : GncNumeric,
+                    'GetClearedBalance' : GncNumeric,
+                    'GetReconciledBalance' : GncNumeric,
+                    'GetPresentBalance' : GncNumeric,
+                    'GetProjectedMinimumBalance' : GncNumeric,
+                    'GetBalanceAsOfDate' : GncNumeric,
+                    'ConvertBalanceToCurrency' : GncNumeric,
+                    'ConvertBalanceToCurrencyAsOfDate' : GncNumeric,
+                    'GetBalanceInCurrency' : GncNumeric,
+                    'GetClearedBalanceInCurrency' : GncNumeric,
+                    'GetReconciledBalanceInCurrency' : GncNumeric,
+                    'GetPresentBalanceInCurrency' : GncNumeric,
+                    'GetProjectedMinimumBalanceInCurrency' : GncNumeric,
+                    'GetBalanceAsOfDateInCurrency' : GncNumeric,
+                    'GetBalanceChangeForPeriod' : GncNumeric,
+                    'GetCommodity' : GncCommodity,
+                    'GetGUID': GUID
+                }
+methods_return_instance(Account, account_dict)
+methods_return_instance_lists(
+    Account, { 'GetSplitList': Split,
+               'get_children': Account,
+               'get_children_sorted': Account,
+               'get_descendants': Account,
+               'get_descendants_sorted': Account
+                       })
+Account.name = property( Account.GetName, Account.SetName )
+
+#GUID
+GUID.add_methods_with_prefix('guid_')
+GUID.add_method('xaccAccountLookup', 'AccountLookup')
+GUID.add_method('xaccTransLookup', 'TransLookup')
+GUID.add_method('xaccSplitLookup', 'SplitLookup')
+
+## define addition methods for GUID object - do we need these
+GUID.add_method('guid_to_string', 'to_string')
+#GUID.add_method('string_to_guid', 'string_to_guid')
+
+guid_dict = {
+                'copy' : GUID,
+                'TransLookup': Transaction,
+                'AccountLookup': Account,
+                'SplitLookup': Split
+            }
+methods_return_instance(GUID, guid_dict)
+
+#GUIDString
+class GUIDString(GnuCashCoreClass):
+    pass
+
+GUIDString.add_constructor_and_methods_with_prefix('string_', 'to_guid')
+
+#Query
+from gnucash_core_c import \
+    QOF_QUERY_AND, \
+    QOF_QUERY_OR, \
+    QOF_QUERY_NAND, \
+    QOF_QUERY_NOR, \
+    QOF_QUERY_XOR
+
+from gnucash_core_c import \
+    QOF_STRING_MATCH_NORMAL, \
+    QOF_STRING_MATCH_CASEINSENSITIVE
+
+from gnucash_core_c import \
+    QOF_COMPARE_LT, \
+    QOF_COMPARE_LTE, \
+    QOF_COMPARE_EQUAL, \
+    QOF_COMPARE_GT, \
+    QOF_COMPARE_GTE, \
+    QOF_COMPARE_NEQ
+
+from gnucash_core_c import \
+    INVOICE_TYPE
+
+from gnucash_core_c import \
+    INVOICE_IS_PAID
+
+class Query(GnuCashCoreClass):
+    pass
+
+Query.add_constructor_and_methods_with_prefix('qof_query_', 'create')
+
+Query.add_method('qof_query_set_book', 'set_book')
+Query.add_method('qof_query_search_for', 'search_for')
+Query.add_method('qof_query_run', 'run')
+Query.add_method('qof_query_add_term', 'add_term')
+Query.add_method('qof_query_add_boolean_match', 'add_boolean_match')
+Query.add_method('qof_query_destroy', 'destroy')
+
+class QueryStringPredicate(GnuCashCoreClass):
+    pass
+
+QueryStringPredicate.add_constructor_and_methods_with_prefix('qof_query_', 'string_predicate')
+
+class QueryBooleanPredicate(GnuCashCoreClass):
+    pass
+
+QueryBooleanPredicate.add_constructor_and_methods_with_prefix('qof_query_', 'boolean_predicate')
+
+class QueryInt32Predicate(GnuCashCoreClass):
+    pass
+
+QueryInt32Predicate.add_constructor_and_methods_with_prefix('qof_query_', 'int32_predicate')