import locale

locale.setlocale(locale.LC_ALL, '')

    def simple_transaction(self, from_acc, to_acc, amount, symbol=None,

                           payee=None):

        if symbol is None:

            # Get the currency from the environment locale

            symbol = locale.localeconv()['int_curr_symbol'].strip()

            payee=payee,

                        amount=Amount(symbol=symbol, amount=-amount)),

                        amount=Amount(symbol=symbol, amount=amount))

        print_balance_accounts(account.accounts, level + 1)

    insert.add_argument('payee',

                        help='The payee line of the transaction')

    insert.add_argument('amount', type=Decimal,

                        help='The amount deducted from from_account and added'

                             ' to to_account')

    insert.add_argument('-s', '--symbol',

                        help='The symbol for the amount, e.g. $ or USD for'

                             ' USD. Defaults to your locale\'s setting.')

                                        args.amount, payee=args.payee,

                                        symbol=args.symbol))

import sys

import logging

import threading

from datetime import datetime

from gi.repository import Gtk

from gi.repository import GLib

from gi.repository import GObject

from accounting.client import Client

_log = logging.getLogger(__name__)

class Accounting(Gtk.Window):

    def __init__(self):

        Gtk.Window.__init__(self, title='Accounting Client')

        self.client = Client()

        self.set_border_width(3)

        # Table

        self.table = Gtk.Table(3, 2, True)

        self.add(self.table)

        # Button

        self.btn_load_transactions = Gtk.Button(label='Load transactions')

        self.btn_load_transactions.connect('clicked', self.on_button_clicked)

        self.spinner = Gtk.Spinner()

        # Transaction stuff

        self.transaction_store = Gtk.ListStore(str, str)

        self.transaction_view = Gtk.TreeView(self.transaction_store)

        renderer = Gtk.CellRendererText()

        date_column = Gtk.TreeViewColumn('Date', renderer, text=0)

        payee_column = Gtk.TreeViewColumn('Payee', renderer, text=1)

        self.transaction_view.append_column(date_column)

        self.transaction_view.append_column(payee_column)

        # Layout

        self.table.attach(self.btn_load_transactions, 0, 1, 0, 1)

        self.table.attach(self.spinner, 1, 2, 0, 1)

        self.table.attach(self.transaction_view, 0, 2, 1, 3)

        # Show

        self.show_all()

        self.spinner.hide()

    def on_button_clicked(self, widget):

        def load_transactions():

            transactions = self.client.get_register()

            GLib.idle_add(self.on_transactions_loaded, transactions)

        self.spinner.show()

        self.spinner.start()

        threading.Thread(target=load_transactions).start()

    def on_transactions_loaded(self, transactions):

        self.spinner.stop()

        self.spinner.hide()

        _log.debug('transactions: %s', transactions)

        self.transaction_store.clear()

        for transaction in transactions:

            self.transaction_store.append([

                transaction.date.strftime('%Y-%m-%d'),

                transaction.payee

            ])

def main(argv=None):

    logging.basicConfig(level=logging.DEBUG)

    GObject.threads_init()

    accounting_win = Accounting()

    accounting_win.connect('delete-event', Gtk.main_quit)

    Gtk.main()

if __name__ == '__main__':

    sys.exit(main())

        self.id = str(uuid.uuid4())

        return ('<{self.__class__.__name__} {self.id} {date}' +

    def __init__(self, app=None, ledger_file=None, ledger_bin=None):

        if app:

            ledger_file = app.config['LEDGER_FILE']

        if transaction.id is None:

            _log.debug('No ID found. Generating an ID.')

        transaction.metadata.update({'Id': transaction.id})

                                '{metadata}'

            metadata=''.join([

    def get_transactions(self):

        return self.reg()

    def update_transaction(self, transaction):

        _log.debug('DUMMY: Updated transaction: %s', transaction)

from accounting.exceptions import AccountingException

    def __init__(self, app=None):

        if not app:

            raise Exception('Missing app keyword argument')

    def update_transaction(self, transaction):

        if transaction.id is None:

            raise AccountingException('The transaction id must be set for'

                                      ' update_transaction calls')

        _log.debug('DUMMY: Update transaction: %s', transaction)

        _t.uuid = transaction.id

            _p.transaction_uuid = transaction.id

                id=o.id,

        types = {c.__name__: c for c in [Amount, Transaction, Posting,

                                         Account]}

storage = Ledger(app=app)

if isinstance(storage, SQLStorage):

    # TODO: Move migration stuff into SQLStorage

    db = storage.db

    migrate = Migrate(app, db)

    manager = Manager(app)

    manager.add_command('db', MigrateCommand)

@app.route('/transaction/<string:transaction_id>', methods=['POST'])

@jsonify_exceptions

def transaction_update(transaction_id=None):

    if transaction_id is None:

        raise AccountingException('The transaction ID cannot be None.')

    transaction = request.json['transaction']

    if transaction.id is not None and not transaction.id == transaction_id:

        raise AccountingException('The transaction data has an ID attribute and'

                                  ' it is not the same ID as in the path')

    elif transaction.id is None:

        transaction.id = transaction_id

    storage.update_transaction(transaction)

    return jsonify(status='OK')

    return jsonify(status='OK')