Beispiel #1
0
def run(args=None, config=None):
    if args is None:
        args = sys.argv[1:]

    parser = argparse.ArgumentParser(description='Synchronize ledger.')
    parser.add_argument('-m',
                        '--max',
                        type=int,
                        default=90,
                        help='maximum number of days to process')
    parser.add_argument('-r',
                        '--resync',
                        action='store_true',
                        default=False,
                        help='do not stop until max days reached')
    parser.add_argument('PATH',
                        nargs='?',
                        help='do not sync; import from OFX \
file')
    parser.add_argument('-a',
                        '--account',
                        type=str,
                        default=None,
                        help='sync only the named account; \
if importing from file, set account name for import')
    parser.add_argument('-l',
                        '--ledger',
                        type=str,
                        default=None,
                        help='specify ledger file to READ for syncing')
    parser.add_argument('-L',
                        '--no-ledger',
                        dest='no_ledger',
                        action='store_true',
                        default=False,
                        help='do not de-duplicate against a ledger file')
    parser.add_argument('-i',
                        '--indent',
                        type=int,
                        default=4,
                        help='number of spaces to use for indentation')
    parser.add_argument('--initial',
                        action='store_true',
                        default=False,
                        help='create initial balance entries')
    parser.add_argument('--fid',
                        type=int,
                        default=None,
                        help='pass in fid value for OFX files that do not \
supply it')
    parser.add_argument('--hardcode-account',
                        type=str,
                        default=None,
                        dest='hardcodeaccount',
                        help='pass in hardcoded account number for OFX files \
to maintain ledger files without real account numbers')
    parser.add_argument('--shorten-account',
                        default=False,
                        action='store_true',
                        dest='shortenaccount',
                        help='shorten all account numbers to last 4 digits \
to maintain ledger files without full account numbers')
    parser.add_argument('--unknown-account',
                        type=str,
                        dest='unknownaccount',
                        default=None,
                        help='specify account name to use when one can\'t be \
found by payee')
    parser.add_argument('--assertions',
                        action='store_true',
                        default=False,
                        help='create balance assertion entries')
    parser.add_argument('-d',
                        '--debug',
                        action='store_true',
                        default=False,
                        help='enable debug logging')
    parser.add_argument('--hledger',
                        action='store_true',
                        default=False,
                        help='force use of hledger (on by default if invoked \
                        as hledger-autosync)')
    parser.add_argument(
        '--payee-format',
        type=str,
        default=None,
        dest='payee_format',
        help="""Format string to use for generating the payee line. Substitutions
        can be written using {memo}, {payee}, {txntype}, {account} or
        {tferaction} for OFX. If the input file is a CSV file,
        substitutions are written using the CSV file column names
        between {}.""")
    parser.add_argument('--python',
                        action='store_true',
                        default=False,
                        help='use the ledger python interface')
    parser.add_argument('--slow',
                        action='store_true',
                        default=False,
                        help='use slow, but possibly more robust, method of \
calling ledger (no subprocess)')
    parser.add_argument('--which',
                        action='store_true',
                        default=False,
                        help='display which version of ledger (cli), hledger, \
or ledger (python) will be used by ledger-autosync to check for previous \
transactions')
    parser.add_argument('--reverse',
                        action='store_true',
                        default=False,
                        help='print CSV transactions in reverse order')
    parser.add_argument('-o',
                        '--ofxconfig',
                        type=str,
                        default=None,
                        help='specify config file for ofxclient')
    parser.add_argument('-y',
                        '--date-format',
                        type=str,
                        default=None,
                        dest="date_format",
                        help="""Format string to use for printing dates.
                        See strftime for details on format string syntax. Default is "%%Y/%%m/%%d"."""
                        )
    parser.add_argument('--no-infer-account',
                        dest="infer_account",
                        action='store_false',
                        default=True,
                        help='disable inference of offset account from payee')
    args = parser.parse_args(args)
    if sys.argv[0][-16:] == "hledger-autosync":
        args.hledger = True

    ledger_file = None
    if args.ledger and args.no_ledger:
        raise LedgerAutosyncException(
            'You cannot specify a ledger file and -L')
    elif args.ledger:
        ledger_file = args.ledger
    else:
        ledger_file = find_ledger_file()
    if args.debug:
        logging.basicConfig(level=logging.DEBUG)

    if ledger_file is None:
        sys.stderr.write("LEDGER_FILE environment variable not set, and no \
.ledgerrc file found, and -l argument was not supplied: running with deduplication disabled. \
All transactions will be printed!\n")
        ledger = None
    elif args.no_ledger:
        ledger = None
    elif args.hledger:
        ledger = HLedger(ledger_file)
    elif args.python:
        ledger = LedgerPython(ledger_file=ledger_file)
    elif args.slow:
        ledger = Ledger(ledger_file=ledger_file, no_pipe=True)
    else:
        ledger = mk_ledger(ledger_file)

    if args.which:
        sys.stderr.write("ledger-autosync is using ")
        if isinstance(ledger, Ledger):
            sys.stderr.write("ledger (cli)\n")
        elif isinstance(ledger, HLedger):
            sys.stderr.write("hledger\n")
        elif isinstance(ledger, LedgerPython):
            sys.stderr.write("ledger.so (python)\n")
        exit()

    config_dir = os.environ.get(
        'XDG_CONFIG_HOME', os.path.join(os.path.expanduser("~"), '.config'))

    load_plugins(config_dir)

    if args.PATH is None:
        if config is None:
            if args.ofxconfig is None:
                config_file = os.path.join(config_dir, 'ofxclient.ini')
            else:
                config_file = args.ofxconfig
            if (os.path.exists(config_file)):
                config = OfxConfig(file_name=config_file)
            else:
                config = OfxConfig()
        accounts = config.accounts()
        if args.account:
            accounts = [
                acct for acct in accounts if acct.description == args.account
            ]
        sync(ledger, accounts, args)
    else:
        _, file_extension = os.path.splitext(args.PATH.lower())
        if file_extension == '.csv':
            import_csv(ledger, args)
        else:
            import_ofx(ledger, args)
Beispiel #2
0
 def setUp(self):
     self.lgr = LedgerPython(os.path.join('fixtures', 'empty.lgr'))
 def setUp(self):
     self.lgr = LedgerPython(self.ledger_path)
     self.dynamic_lgr = LedgerPython(self.dynamic_ledger_path)
Beispiel #4
0
 def setUp(self):
     self.empty_lgr = LedgerPython(os.path.join('fixtures', 'empty.lgr'))
     self.checking_lgr = LedgerPython(
         os.path.join('fixtures', 'checking.lgr'))
 def setUp(self):
     self.empty_lgr = LedgerPython(os.path.join('fixtures', 'empty.lgr'))
     self.lgr = LedgerPython(self.ledger_path)
     self.dynamic_lgr = LedgerPython(self.dynamic_ledger_path)