IntenseFinance/gnucash
3
0
Fork 0
mirror of https://github.com/Gnucash/gnucash.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

Bug #622523 - Python bindings are crash prone when linked to guile

Browse Source 
git-svn-id: svn+ssh://svn.gnucash.org/repo/gnucash/trunk@19294 57a11ea4-9604-0410-9ed3-97b8803252fd
This commit is contained in:
Geert Janssens 2010-06-25 11:06:29 +00:00
parent f490759ebb
commit 9e6d8fb1e9
6 changed files with 675 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/optional/python-bindings/Makefile.am
View File

@ -53,6 +53,8 @@ EXTRA_DIST = \
example_scripts/simple_book.py \
example_scripts/simple_session.py \
example_scripts/simple_test.py \
example_scripts/simple_business_create.py \
example_scripts/simple_invoice_insert.py \
glib.i
MAINTAINERCLEANFILES = gnucash-core.c

152
src/optional/python-bindings/example_scripts/simple_business_create.py Normal file
View File

@ -0,0 +1,152 @@
#!/usr/bin/env python
# simple_business_create.py -- Set up a set of books for business feature use
#
# Copyright (C) 2010 ParIT Worker Co-operative <transparency@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>
# Creates a new book file (or *overwrites* an existing one) that has elements
# in it for business use -- intended as a demonstration program.
# Syntax:
# gnucash-env python simple_business_create.py \
# sqlite3:///home/blah/blah.gnucash
#
# Specificically, this sets up a simple tree, creates a customer, job,
# employee and vendor, creates an unposted invoice for each,
# and posts the customer invoice with a few entries and a tax table.
#
# You may also want to look at simple_invoice_insert.py
from os.path import abspath
from sys import argv
import datetime
from datetime import timedelta
from gnucash import Session, Account, GncNumeric
from gnucash.gnucash_business import Customer, Employee, Vendor, Job, \
Address, Invoice, Entry, TaxTable, TaxTableEntry, GNC_AMT_TYPE_PERCENT, \
GNC_DISC_PRETAX
from gnucash.gnucash_core_c import \
ACCT_TYPE_ASSET, ACCT_TYPE_RECEIVABLE, ACCT_TYPE_INCOME, \
GNC_OWNER_CUSTOMER, ACCT_TYPE_LIABILITY
s = Session(argv[1], True)
# this seems to make a difference in more complex cases
s.save()
book = s.book
root = book.get_root_account()
commod_table = book.get_table()
CAD = commod_table.lookup('CURRENCY', 'CAD')
a = Account(book)
root.append_child(a)
a.SetName('Assets')
a.SetType(ACCT_TYPE_ASSET)
a.SetCommodity(CAD)
a2 = Account(book)
a.append_child(a2)
a2.SetName('Recievables')
a2.SetType(ACCT_TYPE_RECEIVABLE)
a2.SetCommodity(CAD)
a3 = Account(book)
root.append_child(a3)
a3.SetName('Income')
a3.SetType(ACCT_TYPE_INCOME)
a3.SetCommodity(CAD)
a4 = Account(book)
root.append_child(a4)
a4.SetName('Liabilities')
a4.SetType(ACCT_TYPE_LIABILITY)
a4.SetCommodity(CAD)
a5 = Account(book)
a4.append_child(a5)
a5.SetName('Tax payable')
a5.SetType(ACCT_TYPE_LIABILITY)
a5.SetCommodity(CAD)
a6 = Account(book)
a.append_child(a6)
a6.SetName('Bank')
a6.SetType(ACCT_TYPE_ASSET)
a6.SetCommodity(CAD)
# name isn't required, ID and currency are
new_customer = Customer(book, "1", CAD, "Bill & Bob Industries")
# not required, but a good idea because the GUI insists on basic address info
address = new_customer.GetAddr()
address.SetName("Bill & Bob")
address.SetAddr1("201 Nowhere street")
new_employee = Employee(book, "2", CAD, "Reliable employee")
new_vendor = Vendor(book, "3", CAD, "Dependable vendor")
new_job = Job(book, "4", new_vendor, "Good clean, fun")
# 7% tax
tax_table = TaxTable(book, "good tax",
TaxTableEntry(a5, True, GncNumeric(700000, 100000) ) )
invoice_customer = Invoice(book, "5", CAD, new_customer)
customer_extract = invoice_customer.GetOwner()
assert( isinstance(customer_extract, Customer) )
assert( customer_extract.GetName() == new_customer.GetName() )
invoice_employee = Invoice(book, "6", CAD, new_employee)
employee_extract = invoice_employee.GetOwner()
assert( isinstance(employee_extract, Employee) )
assert( employee_extract.GetName() == new_employee.GetName() )
invoice_vendor = Invoice(book, "7", CAD, new_vendor)
vendor_extract = invoice_vendor.GetOwner()
assert( isinstance(vendor_extract, Vendor) )
assert( vendor_extract.GetName() == new_vendor.GetName() )
invoice_job = Invoice(book, "8", CAD, new_job)
job_extract = invoice_job.GetOwner()
assert( isinstance(job_extract, Job) )
assert( job_extract.GetName() == new_job.GetName() )
invoice_entry = Entry(book, invoice_customer)
invoice_entry.SetInvTaxTable(tax_table)
invoice_entry.SetInvTaxIncluded(False)
invoice_entry.SetDescription("excelent product")
invoice_entry.SetQuantity( GncNumeric(1) )
invoice_entry.SetInvAccount(a3)
invoice_entry.SetInvPrice(GncNumeric(1) )
invoice_customer.PostToAccount(a2, datetime.date.today(), datetime.date.today(),
"the memo", True)
new_customer.ApplyPayment(None, a2, a6, GncNumeric(100,100),
GncNumeric(1), datetime.date.today(), "", "")
new_customer.ApplyPayment(invoice_customer, a2, a6, GncNumeric(7,100),
GncNumeric(1), datetime.date.today(), "", "")
s.save()
s.end()

112
src/optional/python-bindings/example_scripts/simple_invoice_insert.py Normal file
View File

@ -0,0 +1,112 @@
#!/usr/bin/env python
# simple_invoice_insert.py -- Add an invoice to a set of books
#
# Copyright (C) 2010 ParIT Worker Co-operative <transparency@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>
# Opens a GnuCash book file and adds an invoice to it for a particular
# customer (by GUID) with a specific ID and value
#
# The account tree and tax tables are assumed to be the same as the ones
# created in simple_business_create.py, but you can edit that to adapt
# this to become an invoice imported for your own books
#
# Syntax:
# gnucash-env python simple_invoice_insert.py \
# sqlite3:///home/blah/blah.gnucash
# dda2ec8e3e63c7715097f852851d6b22 1001 'The Goods' 201.43
from gnucash import Session, GUID, GncNumeric
from gnucash.gnucash_business import Customer, Invoice, Entry
from gnucash.gnucash_core_c import string_to_guid
from os.path import abspath
from sys import argv
from decimal import Decimal
import datetime
def gnc_numeric_from_decimal(decimal_value):
sign, digits, exponent = decimal_value.as_tuple()
# convert decimal digits to a fractional numerator
# equivlent to
# numerator = int(''.join(digits))
# but without the wated conversion to string and back,
# this is probably the same algorithm int() uses
numerator = 0
TEN = int(Decimal(0).radix()) # this is always 10
numerator_place_value = 1
# add each digit to the final value multiplied by the place value
# from least significant to most sigificant
for i in xrange(len(digits)-1,-1,-1):
numerator += digits[i] * numerator_place_value
numerator_place_value *= TEN
if decimal_value.is_signed():
numerator = -numerator
# if the exponent is negative, we use it to set the denominator
if exponent < 0 :
denominator = TEN ** (-exponent)
# if the exponent isn't negative, we bump up the numerator
# and set the denominator to 1
else:
numerator *= TEN ** exponent
denominator = 1
return GncNumeric(numerator, denominator)
s = Session(argv[1], False)
# this seems to make a difference in more complex cases
s.save()
book = s.book
root = book.get_root_account()
commod_table = book.get_table()
CAD = commod_table.lookup('CURRENCY', 'CAD')
my_customer_guid = GUID()
result = string_to_guid(argv[2], my_customer_guid.get_instance())
assert( result )
my_customer = book.CustomerLookup(my_customer_guid)
assert( my_customer != None )
assert( isinstance(my_customer, Customer) )
assets = root.lookup_by_name("Assets")
recievables = assets.lookup_by_name("Recievables")
income = root.lookup_by_name("Income")
invoice = Invoice(book, argv[3], CAD, my_customer )
description = argv[4]
invoice_value = gnc_numeric_from_decimal(Decimal(argv[5]))
tax_table = book.TaxTableLookupByName('good tax')
invoice_entry = Entry(book, invoice)
invoice_entry.SetInvTaxTable(tax_table)
invoice_entry.SetInvTaxIncluded(False)
invoice_entry.SetDescription(description)
invoice_entry.SetQuantity( GncNumeric(1) )
invoice_entry.SetInvAccount(income)
invoice_entry.SetInvPrice(invoice_value)
invoice.PostToAccount(recievables, datetime.date.today(), datetime.date.today(),
"", True)
s.save()
s.end()

273
src/optional/python-bindings/gnucash_business.py
View File

@ -1,7 +1,7 @@
# gnucash_business.py -- High level python wrapper classes for the business
# parts of GnuCash
#
# Copyright (C) 2008 ParIT Worker Co-operative <paritinfo@parit.ca>
# 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
@ -30,18 +30,204 @@ from function_class import \
from gnucash_core import \
GnuCashCoreClass, GncNumeric, GncCommodity, Transaction, \
Split, Book
Split, Book, GncLot, Account
class Customer(GnuCashCoreClass): pass
from gnucash_core_c import GNC_OWNER_CUSTOMER, GNC_OWNER_JOB, \
GNC_OWNER_EMPLOYEE, GNC_OWNER_VENDOR, gncOwnerApplyPayment, \
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
class Employee(GnuCashCoreClass): pass
import datetime
class Vendor(GnuCashCoreClass): pass
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.SetID(id)
self.SetCurrency(currency)
if name != None:
self.SetName(name)
else:
GnuCashCoreClass.__init__(self, instance=instance)
def ApplyPayment(self, invoice, posted_acc, xfer_acc, amount,
exch, date, memo, num):
if invoice != None:
invoice = invoice.get_instance()
trans = gncOwnerApplyPayment(
self.get_instance(), invoice, posted_acc.get_instance(),
xfer_acc.get_instance(), amount.get_instance(),
exch.get_instance(), date, memo, num)
if trans != None:
trans = Transaction(instance=trans)
return trans
class Customer(GnuCashBusinessEntity): pass
class Employee(GnuCashBusinessEntity):
def SetName(self, name):
self.GetAddr().SetName(name)
def GetName(self):
return self.GetAddr().GetName()
class Vendor(GnuCashBusinessEntity): pass
class Job(GnuCashBusinessEntity):
# override the superclass contructor, 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.SetID(id)
self.SetCurrency(currency)
self.SetOwner(owner)
if date_opened == None:
date_opened = datetime.date.today()
self.SetDateOpened(date_opened)
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)
# Customer
Customer.add_constructor_and_methods_with_prefix('gncCustomer', 'Create')
@ -51,7 +237,8 @@ customer_dict = {
'GetDiscount' : GncNumeric,
'GetCredit' : GncNumeric,
'GetTerms' : BillTerm,
'GetCurrency' : GncCommodity
'GetCurrency' : GncCommodity,
'GetTaxTable': TaxTable,
}
methods_return_instance(Customer, customer_dict)
@ -73,10 +260,17 @@ Vendor.add_constructor_and_methods_with_prefix('gncVendor', 'Create')
vendor_dict = {
'GetAddr' : Address,
'GetTerms' : BillTerm,
'GetCurrency' : GncCommodity
'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')
@ -90,3 +284,68 @@ billterm_dict = {
'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')
# 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,
'ReturnValue': GncNumeric,
'ReturnDiscountValue': GncNumeric,
'ReturnTaxValue': GncNumeric,
'GetInvoice': Invoice,
'GetBill': Invoice
}
Entry.decorate_functions(
decorate_to_return_instance_instead_of_owner,
'GetBillTo' )

82
src/optional/python-bindings/gnucash_core.i
View File

@ -53,6 +53,11 @@
#include "gncVendor.h"
#include "gncAddress.h"
#include "gncBillTerm.h"
#include "gncOwner.h"
#include "gncInvoice.h"
#include "gncJob.h"
#include "gncEntry.h"
#include "gncTaxTable.h"
%}
%include <timespec.i>
@ -86,6 +91,79 @@
%include <gnc-commodity.h>
%include <gncOwner.h>
%typemap(out) GncOwner * {
GncOwnerType owner_type = gncOwnerGetType($1);
PyObject * owner_tuple = PyTuple_New(2);
PyTuple_SetItem(owner_tuple, 0, PyInt_FromLong( (long) owner_type ) );
PyObject * swig_wrapper_object;
if (owner_type == GNC_OWNER_CUSTOMER ){
swig_wrapper_object = SWIG_NewPointerObj(
gncOwnerGetCustomer($1), $descriptor(GncCustomer *), 0);
}
else if (owner_type == GNC_OWNER_JOB){
swig_wrapper_object = SWIG_NewPointerObj(
gncOwnerGetJob($1), $descriptor(GncJob *), 0);
}
else if (owner_type == GNC_OWNER_VENDOR){
swig_wrapper_object = SWIG_NewPointerObj(
gncOwnerGetVendor($1), $descriptor(GncVendor *), 0);
}
else if (owner_type == GNC_OWNER_EMPLOYEE){
swig_wrapper_object = SWIG_NewPointerObj(
gncOwnerGetEmployee($1), $descriptor(GncEmployee *), 0);
}
else {
swig_wrapper_object = Py_None;
Py_INCREF(Py_None);
}
PyTuple_SetItem(owner_tuple, 1, swig_wrapper_object);
$result = owner_tuple;
}
%typemap(in) GncOwner * {
GncOwner * temp_owner = gncOwnerCreate();
void * pointer_to_real_thing;
if ((SWIG_ConvertPtr($input, &pointer_to_real_thing,
$descriptor(GncCustomer *),
SWIG_POINTER_EXCEPTION)) == 0){
gncOwnerInitCustomer(temp_owner, (GncCustomer *)pointer_to_real_thing);
$1 = temp_owner;
}
else if ((SWIG_ConvertPtr($input, &pointer_to_real_thing,
$descriptor(GncJob *),
SWIG_POINTER_EXCEPTION)) == 0){
gncOwnerInitJob(temp_owner, (GncJob *)pointer_to_real_thing);
$1 = temp_owner;
}
else if ((SWIG_ConvertPtr($input, &pointer_to_real_thing,
$descriptor(GncVendor *),
SWIG_POINTER_EXCEPTION)) == 0){
gncOwnerInitVendor(temp_owner, (GncVendor *)pointer_to_real_thing);
$1 = temp_owner;
}
else if ((SWIG_ConvertPtr($input, &pointer_to_real_thing,
$descriptor(GncEmployee *),
SWIG_POINTER_EXCEPTION)) == 0){
gncOwnerInitEmployee(temp_owner, (GncEmployee *)pointer_to_real_thing);
$1 = temp_owner;
}
else {
PyErr_SetString(
PyExc_ValueError,
"Python object passed to function with GncOwner * argument "
"couldn't be converted back to pointer of that type");
return NULL;
}
}
%typemap(freearg) GncOwner * {
gncOwnerDestroy($1);
}
%include <gnc-lot.h>
//business-core includes
@ -94,6 +172,10 @@
%include <gncVendor.h>
%include <gncAddress.h>
%include <gncBillTerm.h>
%include <gncInvoice.h>
%include <gncJob.h>
%include <gncEntry.h>
%include <gncTaxTable.h>
%init %{

63
src/optional/python-bindings/gnucash_core.py
View File

@ -28,9 +28,22 @@ from function_class import \
default_arguments_decorator, method_function_returns_instance, \
methods_return_instance
from gnucash_core_c import gncInvoiceLookup, gncInvoiceGetInvoiceFromTxn, \
gncInvoiceGetInvoiceFromLot, gncEntryLookup, gncInvoiceLookup, \
gncCustomerLookup, gncVendorLookup, gncJobLookup, gncEmployeeLookup, \
gncTaxTableLookup, gncTaxTableLookupByName
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)
@ -135,7 +148,45 @@ class Book(GnuCashCoreClass):
get_root_account -- Returns the root level Account
get_table -- Returns a commodity lookup table, of type GncCommodityTable
"""
pass
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)
class GncNumeric(GnuCashCoreClass):
"""Object used by GnuCash to store all numbers. Always consists of a
@ -170,7 +221,10 @@ class GncCommodityTable(GnuCashCoreClass):
pass
class GncLot(GnuCashCoreClass):
pass
def GetInvoiceFromLot(self):
from gnucash_business import Invoice
return self.do_lookup_create_oo_instance(
gncInvoiceGetInvoiceFromLot, Invoice )
class Transaction(GnuCashCoreClass):
"""A GnuCash Transaction
@ -182,6 +236,11 @@ class Transaction(GnuCashCoreClass):
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 )
class Split(GnuCashCoreClass):
"""A GnuCash Split