new_book_with_opening_balances.py File Reference

Replicate the account structure of a book and apply basis opening balances from the original. More...

Go to the source code of this file.

Functions
	new_book_with_opening_balances.initialize_split (book, value, account, trans)
	new_book_with_opening_balances.record_opening_balance (original_account, new_account, new_book, opening_balance_per_currency, commodity_tuple)
	new_book_with_opening_balances.recursivly_build_account_tree (original_parent_account, new_parent_account, new_book, new_commodity_table, opening_balance_per_currency, account_types_to_open)
	new_book_with_opening_balances.reconstruct_account_name_with_mnemonic (account_tuple, mnemonic)
	new_book_with_opening_balances.find_or_make_account (account_tuple, root_account, book, currency)
	new_book_with_opening_balances.choke_on_none_for_no_account (opening_account, extra_string)
	new_book_with_opening_balances.create_opening_balance_transaction (commodtable, namespace, mnemonic, new_book_root, new_book, opening_trans, opening_amount, simple_opening_name_used)
	new_book_with_opening_balances.main ()

Variables
tuple	new_book_with_opening_balances.OPENING_DATE = (1, 1, 2011)
	new_book_with_opening_balances.ACCOUNT_TYPES_TO_OPEN
tuple	new_book_with_opening_balances.OPENING_BALANCE_ACCOUNT = ( 'Equity', 'Opening Balances')
tuple	new_book_with_opening_balances.PREFERED_CURRENCY_FOR_SIMPLE_OPENING_BALANCE = ("CURRENCY", "CAD")

Detailed Description

Replicate the account structure of a book and apply basis opening balances from the original.

Author

Mark Jenkins, ParIT Worker Co-operative mark@.nosp@m.pari.nosp@m.t.ca

Definition in file new_book_with_opening_balances.py.

Function Documentation

choke_on_none_for_no_account()

new_book_with_opening_balances.choke_on_none_for_no_account	(		opening_account,
			extra_string
	)

Definition at line 245 of file new_book_with_opening_balances.py.

def choke_on_none_for_no_account(opening_account, extra_string ):
    if opening_account == None:
        raise Exception("account currency and name mismatch, " + extra_string)
 

create_opening_balance_transaction()

new_book_with_opening_balances.create_opening_balance_transaction	(		commodtable,
			namespace,
			mnemonic,
			new_book_root,
			new_book,
			opening_trans,
			opening_amount,
			simple_opening_name_used
	)

Definition at line 249 of file new_book_with_opening_balances.py.

                                       simple_opening_name_used):
    currency = commodtable.lookup(namespace, mnemonic)
    assert( currency.get_instance() != None )
 
    if simple_opening_name_used:
        account_pieces = reconstruct_account_name_with_mnemonic(
            OPENING_BALANCE_ACCOUNT,
            mnemonic)
        opening_account = find_or_make_account(
            account_pieces, new_book_root, new_book, currency )
        choke_on_none_for_no_account(opening_account,
                                     ', '.join(account_pieces) )
    else:
        opening_account = find_or_make_account(OPENING_BALANCE_ACCOUNT,
                                               new_book_root, new_book,
                                               currency )
        simple_opening_name_used = True
        if opening_account == None:
            account_pieces = reconstruct_account_name_with_mnemonic(
                OPENING_BALANCE_ACCOUNT,
                mnemonic)
            opening_account = find_or_make_account(
                account_pieces, new_book_root, new_book, currency )
            choke_on_none_for_no_account(opening_account,
                                             ', '.join(account_pieces) )
 
    # we don't need to use the opening balance account at all if all
    # the accounts being given an opening balance balance out
    if opening_amount.num() != 0:
        initialize_split(new_book, opening_amount, opening_account,
                         opening_trans)
 
    opening_trans.SetDate( *OPENING_DATE )
    opening_trans.SetCurrency(currency)
    opening_trans.SetDescription("Opening Balance")
    opening_trans.CommitEdit()
 
    return simple_opening_name_used
        

find_or_make_account()

new_book_with_opening_balances.find_or_make_account	(		account_tuple,
			root_account,
			book,
			currency
	)

Definition at line 222 of file new_book_with_opening_balances.py.

                         currency ):
    current_account_name, account_path = account_tuple[0], account_tuple[1:]
    current_account = root_account.lookup_by_name(current_account_name)
    if current_account == None:
        current_account = Account(book)
        current_account.SetName(current_account_name)
        current_account.SetCommodity(currency)
        root_account.append_child(current_account)
    
    if len(account_path) > 0:
        return find_or_make_account(account_path, current_account, book,
                                    currency)
    else:
        account_commod = current_account.GetCommodity()
        if (account_commod.get_mnemonic(),
            account_commod.get_namespace() ) == \
            (currency.get_mnemonic(),
             currency.get_namespace()) :
            return current_account
        else:
            return None
 

initialize_split()

new_book_with_opening_balances.initialize_split	(		book,
			value,
			account,
			trans
	)

Definition at line 137 of file new_book_with_opening_balances.py.

def initialize_split(book, value, account, trans):
    split = Split(book)
    split.SetValue(value)
    split.SetAccount(account)
    split.SetParent(trans)
    return split
 
 

main()

new_book_with_opening_balances.main

(

)

Definition at line 291 of file new_book_with_opening_balances.py.

def main():
 
    if len(argv) < 3:
        print('not enough parameters')
        print('usage: new_book_with_opening_balances.py {source_book_url} {destination_book_url}')
        print('examples:')
        print("python3 new_book_with_opening_balances.py '/home/username/test.gnucash' 'sqlite3:///home/username/new_test.gnucash'")
        print("python3 new_book_with_opening_balances.py '/home/username/test.gnucash' 'xml:///crypthome/username/finances/new_test.gnucash'")
        return
 
    #have everything in a try block to unable us to release our hold on stuff to the extent possible
    try:
        original_book_session = Session(argv[1], SessionOpenMode.SESSION_NORMAL_OPEN)
        new_book_session = Session(argv[2], SessionOpenMode.SESSION_NEW_STORE)
        new_book = new_book_session.get_book()
        new_book_root = new_book.get_root_account()
 
        commodtable = new_book.get_table()
        # we discovered that if we didn't have this save early on, there would
        # be trouble later
        new_book_session.save()
 
        opening_balance_per_currency = {}
        recursivly_build_account_tree(
            original_book_session.get_book().get_root_account(),
            new_book_root,
            new_book,
            commodtable,
            opening_balance_per_currency,
            ACCOUNT_TYPES_TO_OPEN
            )
 
        (namespace, mnemonic) = PREFERED_CURRENCY_FOR_SIMPLE_OPENING_BALANCE
        if (namespace, mnemonic) in opening_balance_per_currency:
            opening_trans, opening_amount = opening_balance_per_currency[
                (namespace, mnemonic)]
            simple_opening_name_used = create_opening_balance_transaction(
                commodtable, namespace, mnemonic,
                new_book_root, new_book,
                opening_trans, opening_amount,
                False )
            del opening_balance_per_currency[
                PREFERED_CURRENCY_FOR_SIMPLE_OPENING_BALANCE]
        else:
            simple_opening_name_used = False
 
        for (namespace, mnemonic), (opening_trans, opening_amount) in \
                opening_balance_per_currency.items() :
            simple_opening_name_used = create_opening_balance_transaction(
                commodtable, namespace, mnemonic,
                new_book_root, new_book,
                opening_trans, opening_amount,
                simple_opening_name_used )
 
        new_book_session.save()
        new_book_session.end()
        original_book_session.end()
    except:
        if "original_book_session" in locals():
            original_book_session.end()
 
        if "new_book_session" in locals():
            new_book_session.end()
 
        raise
    
 

reconstruct_account_name_with_mnemonic()

new_book_with_opening_balances.reconstruct_account_name_with_mnemonic	(		account_tuple,
			mnemonic
	)

Definition at line 216 of file new_book_with_opening_balances.py.

def reconstruct_account_name_with_mnemonic(account_tuple, mnemonic):
    opening_balance_account_pieces = list(account_tuple)
    opening_balance_account_pieces[
        len(opening_balance_account_pieces) - 1 ] += " - " + mnemonic    
    return opening_balance_account_pieces
 

record_opening_balance()

new_book_with_opening_balances.record_opening_balance	(		original_account,
			new_account,
			new_book,
			opening_balance_per_currency,
			commodity_tuple
	)

Definition at line 145 of file new_book_with_opening_balances.py.

                           ):
    # create an opening balance if the account type is right
    if new_account.GetType() in ACCOUNT_TYPES_TO_OPEN:
        final_balance = original_account.GetBalance()
        if final_balance.num() != 0:
            # if there is a new currency type, associate with the currency
            # a Transaction which will be the opening transaction for that
            # currency and a GncNumeric value which will be the opening
            # balance account amount
            if commodity_tuple not in opening_balance_per_currency:
                trans = Transaction(new_book)
                trans.BeginEdit()
                opening_balance_per_currency[commodity_tuple] = (
                    trans, GncNumeric(0, 1) )
            trans, total = opening_balance_per_currency[commodity_tuple]
 
            new_total = total.sub(
                final_balance,
                GNC_DENOM_AUTO, GNC_HOW_DENOM_EXACT )
            
            initialize_split(
                new_book,
                final_balance,
                new_account, trans)
            opening_balance_per_currency[commodity_tuple] = \
                (trans, new_total )
 

recursivly_build_account_tree()

new_book_with_opening_balances.recursivly_build_account_tree	(		original_parent_account,
			new_parent_account,
			new_book,
			new_commodity_table,
			opening_balance_per_currency,
			account_types_to_open
	)

Definition at line 174 of file new_book_with_opening_balances.py.

                                  account_types_to_open ):
 
    for child in original_parent_account.get_children():
        original_account = child
        new_account = Account(new_book)
        # attach new account to its parent
        new_parent_account.append_child(new_account)
 
        # copy simple attributes
        for attribute in ('Name', 'Type', 'Description', 'Notes',
                          'Code', 'TaxRelated', 'Placeholder'):
            # new_account.SetAttribute( original_account.GetAttribute() )
            getattr(new_account, 'Set' + attribute)(
                getattr(original_account, 'Get' + attribute)() )
 
        # copy commodity
        orig_commodity = original_account.GetCommodity()
        namespace = orig_commodity.get_namespace()
        mnemonic = orig_commodity.get_mnemonic()
        new_commodity = new_commodity_table.lookup(namespace, mnemonic)
        if new_commodity == None:
            new_commodity = orig_commodity.clone(new_book)
            new_commodity_table.insert(new_commodity)
        new_account.SetCommodity(new_commodity)
 
        record_opening_balance( original_account, new_account,
                                new_book, opening_balance_per_currency,
                                (namespace, mnemonic),
                                )
 
        recursivly_build_account_tree(original_account,
                                      new_account,
                                      new_book,
                                      new_commodity_table,
                                      opening_balance_per_currency,
                                      account_types_to_open)
 

Variable Documentation

ACCOUNT_TYPES_TO_OPEN

new_book_with_opening_balances.ACCOUNT_TYPES_TO_OPEN

Initial value:

=  set( (
        ACCT_TYPE_BANK,
        ACCT_TYPE_CASH,
        ACCT_TYPE_CREDIT,
        ACCT_TYPE_ASSET,
        ACCT_TYPE_LIABILITY,
        ACCT_TYPE_STOCK,
        ACCT_TYPE_MUTUAL,
        ACCT_TYPE_INCOME,
        ACCT_TYPE_EXPENSE,
        ACCT_TYPE_EQUITY,
        ACCT_TYPE_RECEIVABLE,
        ACCT_TYPE_PAYABLE,
        ACCT_TYPE_TRADING,
))

Definition at line 90 of file new_book_with_opening_balances.py.

OPENING_BALANCE_ACCOUNT

tuple new_book_with_opening_balances.OPENING_BALANCE_ACCOUNT = ( 'Equity', 'Opening Balances')

Definition at line 130 of file new_book_with_opening_balances.py.

OPENING_DATE

tuple new_book_with_opening_balances.OPENING_DATE = (1, 1, 2011)

Definition at line 87 of file new_book_with_opening_balances.py.

PREFERED_CURRENCY_FOR_SIMPLE_OPENING_BALANCE

tuple new_book_with_opening_balances.PREFERED_CURRENCY_FOR_SIMPLE_OPENING_BALANCE = ("CURRENCY", "CAD")

Definition at line 135 of file new_book_with_opening_balances.py.