def test_session_with_new_file(self): """create Session with new xml file""" from tempfile import TemporaryDirectory from urllib.parse import urlunparse with TemporaryDirectory() as tempdir: uri = urlunparse(("xml", tempdir, "tempfile", "", "", "")) with Session(uri, SessionOpenMode.SESSION_NEW_STORE) as ses: pass # try to open nonexistent file without NEW mode - should raise Exception uri = urlunparse(("xml", tempdir, "tempfile2", "", "", "")) with Session() as ses: with self.assertRaises(GnuCashBackendException): ses.begin(uri, mode=SessionOpenMode.SESSION_NORMAL_OPEN) # try to open nonexistent file without NEW mode - should raise Exception # use deprecated arg is_new uri = urlunparse(("xml", tempdir, "tempfile2", "", "", "")) with Session() as ses: with self.assertRaises(GnuCashBackendException): ses.begin(uri, is_new=False) uri = urlunparse(("xml", tempdir, "tempfile3", "", "", "")) with Session() as ses: ses.begin(uri, mode=SessionOpenMode.SESSION_NEW_STORE) # test using deprecated args uri = urlunparse(("xml", tempdir, "tempfile4", "", "", "")) with Session() as ses: ses.begin(uri, is_new=True)
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 "gnucash-env python new_book_with_opening_balances.py '/home/username/test.gnucash' 'sqlite3:///home/username/new_test.gnucash'" print "gnucash-env python 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], is_new=False) new_book_session = Session(argv[2], is_new=True) 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.iteritems() : 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
def runTest(self): self.instrument_main() try: from accregex import Account from accregex.AccountUtil import gnc_numeric_to_python_Decimal from gnucash import Session session = Session(AccregexTest.reg_doc_example, is_new=False, ignore_lock=False) parking_expense_account = Account.get_account(session.book.get_root_account(), parking_expense_account_full_name) actual_balance = gnc_numeric_to_python_Decimal(parking_expense_account.GetBalance()) expected_balance = Decimal(25) self.assertEqual(actual_balance, expected_balance) #TODO: check that the actual transaction in Assets:Current Assets:Checking Account was changed session.end() #put the gnucash file back the way we found it shutil.move(AccregexTest.reg_doc_example + ".bak", AccregexTest.reg_doc_example) except: #in case of error close the session and re-raise #equivalent to a "finally" block if "session" in locals(): session.end() raise
def test_get_book_from_current_session(self): from gnucash import _sw_app_utils from gnucash import Book self.ses_instance = _sw_app_utils.gnc_get_current_session() self.ses = Session(instance=self.ses_instance) self.book = self.ses.get_book() self.assertIsInstance(obj=self.book, cls=Book)
def gnc_open(cls, path=None): if GncFile.status: return GncFile.status else: if path is not None: GncFile.path = path else: path = GncFile.path if not os.path.exists(path): print """GnuCash file (%s) does not exist. """ % path raise Exception('GnuCash file missing') if os.path.exists(path + '.LCK'): print """Lock file exists. Is GNUCash running?\n""" raise Exception('GnuCash locked') try: GncFile.s = Session(GncFile.path, is_new=False) except: raise Exception('Could not open GnuCash file') GncFile.book = GncFile.s.book GncFile.root = GncFile.book.get_root_account() GncFile.commod_table = GncFile.book.get_table() GncFile.USD = GncFile.commod_table.lookup('CURRENCY', 'USD') GncFile.status = True return GncFile.status
def write_transactions_to_gnucash(gnucash_file, currency, all_items, dry_run=False, date_from=None): logging.debug('Opening GnuCash file %s..', gnucash_file) session = Session(gnucash_file) book = session.book commod_tab = book.get_table() currency = commod_tab.lookup('ISO4217', currency) if date_from: date_from = datetime.datetime.strptime(date_from, '%Y-%m-%d') imported_items = set() for item in all_items: if date_from and item.date < date_from: logging.info('Skipping entry %s (%s)', item.date.strftime('%Y-%m-%d'), item.split_amount) continue if item.as_tuple() in imported_items: logging.info('Skipping entry %s (%s) --- already imported!', item.date.strftime('%Y-%m-%d'), item.split_amount) continue add_transaction(book, item, currency) imported_items.add(item.as_tuple()) if dry_run: logging.debug('** DRY-RUN **') else: logging.debug('Saving GnuCash file..') session.save() session.end()
def main(): args = parse_cmdline() if args.version: print VERSION exit(0) if args.verbose: loglevel = logging.DEBUG elif args.quiet: loglevel = logging.WARN else: loglevel = logging.INFO logging.basicConfig(level=loglevel) rules = readrules(args.rulesfile) account_path = re.split(':', args.ac2fix) gnucash_session = Session(args.gnucash_file, is_new=False) total = 0 imbalance = 0 fixed = 0 try: root_account = gnucash_session.book.get_root_account() orig_account = account_from_path(root_account, account_path) imbalance_pattern = re.compile(args.imbalance_ac) for split in orig_account.GetSplitList(): total += 1 trans = split.parent splits = trans.GetSplitList() trans_date = date.fromtimestamp(trans.GetDate()) trans_desc = trans.GetDescription() trans_memo = trans.GetNotes() for split in splits: ac = split.GetAccount() acname = ac.GetName() logging.debug('%s: %s => %s', trans_date, trans_desc, acname) if imbalance_pattern.match(acname): imbalance += 1 search_str = trans_desc if args.use_memo: search_str = trans_memo newac = get_ac_from_str(search_str, rules, root_account) if newac != "": logging.debug('\tChanging account to: %s', newac.GetName()) split.SetAccount(newac) fixed += 1 if not args.nochange: gnucash_session.save() logging.info('Total splits=%s, imbalance=%s, fixed=%s', total, imbalance, fixed) except Exception as ex: logging.error(ex) gnucash_session.end()
def create_transactions(args, conf, url, txs, dry_run): try: session = Session(url, ignore_lock=True) except GnuCashBackendException, backend_exception: print "Error: %s" % backend_exception exit(1)
def sessionForFile(input_file): try: return Session(os.path.abspath(input_file)) except GnuCashBackendException, backend_exception: if ERR_BACKEND_LOCKED in backend_exception.errors: eprint("Cannot open %s, file is locked." % input_file) raise
def __init__(self, file, currency, is_new=False): self.session = Session(file, is_new) try: self.book = self.session.book self.commod_tab = self.book.get_table() self.currency = self.commod_tab.lookup('ISO4217', currency) self.root = self.book.get_root_account() except Exception as ex: pass
def account_choices(book=None): choices = [("", "---------")] if not book: session = Session(settings.GNUCASH_FILE) book = session.book for ac in queries.get_accounts(book.get_root_account()): choices.append((ac.name, ac.name)) if "session" in locals(): session.end() return choices
def __init__(self, book_uri): self._session = Session(book_uri=book_uri) self._book = self._session.book self._root_account = self._book.get_root_account() self._commodity_table = self._book.get_table() # todo: implement as class w/ getattr self.commods = {} self.commods['USD'] = self._commodity_table.lookup("ISO4217", "USD")
def customer_choices(book=None): choices = [("", "---------")] if not book: session = Session(settings.GNUCASH_FILE) book = session.book for c in queries.get_customers(book): choices.append((c.GetID(), c.GetName())) if "session" in locals(): session.end() return choices
def find_av_main(): exe = argv[0].split('/')[-1] if len(argv) < 6: print("NOT ENOUGH parameters!") print("usage: {} <book url> <year> <month> <day> <space-separated path to the account of interest>".format(exe)) print("PROGRAM EXIT!") return print("\nrunning {} at run-time: {}\n".format(exe, str(datetime.now()))) global gnucash_session try: (gnucash_file, str_year, str_month, str_day) = argv[1:5] print("find asset values in {} on {}-{}-{}".format(gnucash_file, str_year, str_month, str_day)) val_year, val_month, val_day = [int(blah) for blah in (str_year, str_month, str_day)] date_of_interest = date(val_year, val_month, val_day) account_path = argv[5:] print("account_path = {}\n".format(str(account_path))) gnucash_session = Session(gnucash_file, is_new=False) book = gnucash_session.book commod_tab = book.get_table() # noinspection PyPep8Naming CAD = commod_tab.lookup("ISO4217", "CAD") root_account = book.get_root_account() account_of_interest = account_from_path(root_account, account_path) acct_name = account_of_interest.GetName() total = get_asset_balance(account_of_interest, date_of_interest, CAD) # get the list of all descendant accounts descendants = account_of_interest.get_descendants() if len(descendants) > 0: # get the values for EACH sub-account too print("\nDescendants of {}:".format(acct_name)) for subAcct in descendants: total += get_asset_balance(subAcct, date_of_interest, CAD) print("total {} value = {}${}".format(acct_name, CAD.get_mnemonic(), total)) # no save needed, we're just reading... gnucash_session.end() except Exception as ae: print("Exception: {}".format(ae)) if "gnucash_session" in locals() and gnucash_session is not None: gnucash_session.end() print("\n >>> PROGRAM ENDED.")
def setUp(self): self.util = Util() self.account = Nubank(self.util.DEFAULT_ACCOUNT_SRC_FILE) self.ledger = Ledger(self.account, self.util.DEFAULT_CURRENCY, False, self.util.DEFAULT_GNUCASH_FILE) session = Session(self.util.DEFAULT_GNUCASH_FILE) self.book = session.book self.currency = self.book.get_table().lookup( 'ISO4217', self.util.DEFAULT_CURRENCY) session.end()
def open_book(gnucashfile, account2fix): """Read a GNU Cash file :param gnucashfile: path to the GNU Cash file :param account2fix: list with the path of the account :returns: session object, root account and origin account :rtype: """ gnucash_session = Session(gnucashfile, is_new=False) root_account = gnucash_session.book.get_root_account() orig_account = account_from_path(root_account, account2fix) return (gnucash_session, root_account, orig_account)
def main(): original_book_session = Session(argv[1], is_new=False) new_book_session = Session(argv[2], in_new=True) 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.iteritems() : 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()
def __init__(self, fmon, gnc_file, mode): self.prod = (mode == PROD) self.mon_file = fmon self.session = Session(gnc_file) self.book = self.session.book self.root = self.book.get_root_account() self.root.get_instance() self.price_db = self.book.get_price_db() commod_tab = self.book.get_table() self.currency = commod_tab.lookup("ISO4217", "CAD")
def handle(self, *args, **options): try: s = Session(settings.GNUCASH_FILE) book = s.book with open(args[0], "r") as f: reader = csv.DictReader(f) for row in reader: number = row["invoice"] amount = Decimal(row["amount"]) date = parser.parse(row["date"]) try: pay_invoice(book, number, amount, date) except PaymentExists as e: print("%s... skipping" % e) s.save() finally: s.end()
def prepare_session(self): """ initialization needed for a Gnucash session :return: message """ self.logger.print_info("prepare_session()", BLUE) msg = TEST try: session = Session(self.gnc_file) self.book = session.book owner = self.monarch_record.get_owner() self.logger.print_info("Owner = {}".format(owner), GREEN) self.set_gnc_rec(InvestmentRecord(owner)) self.create_gnucash_info() if self.mode == PROD: self.logger.print_info("Mode = {}: COMMIT Price DB edits and Save session.".format(self.mode), GREEN) if self.domain != TRADE: self.price_db.commit_edit() # only ONE session save for the entire run session.save() session.end() session.destroy() msg = self.logger.get_log() except Exception as se: msg = "prepare_session() EXCEPTION!! '{}'".format(repr(se)) self.logger.print_error(msg) if "session" in locals() and session is not None: session.end() session.destroy() raise se return msg
def open_gnucash(gnucash_file): from gnucash import Session from financespy import gnucash_backend from financespy.gnucash_backend import GnucashBackend path = Path(gnucash_file) metadata_file = re.sub("[.]gnucash$", ".json", path.name) metadata = read_metadata(str(path.parent / metadata_file)) session = Session(gnucash_file) gnucash_account = gnucash_backend.account_for( session, metadata.properties["account_backend"] ) if not metadata.categories: metadata.categories = gnucash_backend.categories_from( session, metadata.properties["account_categories"] ) backend = GnucashBackend(session=session, account=gnucash_account) return Account(backend, metadata)
def prepare_session(self): """ Take the information from a transaction collection and produce Gnucash transactions to write to a Gnucash file :return: message """ print_info("prepare_session()", MAGENTA) msg = TEST try: session = Session(self.gnc_file) self.book = session.book print_info("Owner = {}".format(self.tx_coll[OWNER]), GREEN) self.report_info = InvestmentRecord(self.tx_coll[OWNER]) self.create_gnucash_info() if self.mode == PROD: msg = "Mode = {}: COMMIT Price DB edits and Save session.".format( self.mode) print_info(msg, GREEN) self.price_db.commit_edit() # only ONE session save for the entire run session.save() session.end() session.destroy() except Exception as e: msg = "prepare_session() EXCEPTION!! '{}'".format(repr(e)) print_error(msg) if "session" in locals() and session is not None: session.end() session.destroy() raise return msg
if terms: for term in terms: query.add_term(*term) splits = [] for split in query.run(): split = Split( instance=split) # ToDo: query.run() should return objects splits.append(split) query.destroy() return splits with Session(uri, SessionOpenMode.SESSION_NEW_STORE) as ses: book = ses.get_book() accountA, accountB = createAccounts(book) createRandomTransactions(book, accountA, accountB) # TRANSACTIONS # # get all transactions transactions_all = query_transactions(book) print("Query all: " + str(len(transactions_all)) + " transactions.") # query date threshold = datetime.datetime(1950, 1, 1) QOF_DATE_MATCH_NORMAL = 2 terms = [(['date-posted'],
#!/usr/bin/env python ## @file # @brief Simple example for a book # @ingroup python_bindings_examples import sys from gnucash import Session # We need to tell GnuCash the data format to create the new file as (xml://) uri = "xml:///tmp/simple_book.gnucash" print("uri:", uri) ses = Session(uri, is_new=True) book = ses.get_book() #Call some methods that produce output to show that Book works book.get_root_account().SetDescription("hello, book") print("Book is saved:", not book.session_not_saved()) print("saving...") ses.save() print("Book is saved:", not book.session_not_saved()) ses.end()
# Django setup # from http://www.b-list.org/weblog/2007/sep/22/standalone-django-scripts/ # This script needs to be callable from the command line, but it also needs # to know about the Django project's database and other settings. from django.core.management import setup_environ import settings # only works due to path fuckery above setup_environ(settings) from gnucash_data import models from utils.AsciiDammit import asciiDammit # make sure we can begin a session models.Lock.check_can_obtain() # begin GnuCash API session session = Session(settings.GNUCASH_CONN_STRING) debug = False def debug_print(s): if debug: print s def get_transaction_string(t): memo = txinfo.get('memo', '') if memo: memo = ' / ' + memo return "'%s%s' on %s for %s" \ % (t['description'], memo,
def test_app_utils_get_current_session(self): from gnucash import _sw_app_utils self.ses_instance = _sw_app_utils.gnc_get_current_session() self.ses = Session(instance=self.ses_instance) self.assertIsInstance(obj=self.ses, cls=Session)
#!/usr/bin/env python3 ## @file # @brief Example Script simple sqlite create # @ingroup python_bindings_examples from gnucash import Session, Account from os.path import abspath from gnucash.gnucash_core_c import ACCT_TYPE_ASSET s = Session('sqlite3://%s' % abspath('test.blob'), is_new=True) # this seems to make a difference in more complex cases s.save() book = s.book root = book.get_root_account() a = Account(book) root.append_child(a) a.SetName('wow') a.SetType(ACCT_TYPE_ASSET) commod_table = book.get_table() a.SetCommodity( commod_table.lookup('CURRENCY', 'CAD') ) s.save() s.end()
def test_session_mode(self): """use mode argument""" self.ses = Session(mode=SessionOpenMode.SESSION_NORMAL_OPEN)
def test_session_deprecated_arguments(self): """use deprecated arguments ignore_lock, is_new, force_new""" self.ses = Session(ignore_lock=False, is_new=True, force_new=False)
def test_create_empty_session(self): self.ses = Session()