diff --git a/oxrlib/commands/historical.py b/oxrlib/commands/historical.py index eb41f560823e15d8ae4ac1702a9c1679cda03865..854eba7960f7cc34e058b8deee62335299685410 100644 --- a/oxrlib/commands/historical.py +++ b/oxrlib/commands/historical.py @@ -12,9 +12,11 @@ except ImportError: import enum34 as enum class Formatter: - def __init__(self, rate, signed_currencies=(), base_fmt='#,##0.###', + def __init__(self, cost_rates, price_rates=None, + signed_currencies=(), base_fmt='#,##0.###', rate_precision=5, denomination=None): - self.rate = rate + self.cost_rates = cost_rates + self.price_rates = price_rates self.base_fmt = base_fmt self.base_fmt_noprec = base_fmt.rsplit('.', 1)[0] self.signed_currencies = set(code for code in signed_currencies @@ -48,7 +50,7 @@ class Formatter: def format_rate_pair(self, from_curr, to_curr): from_amt = 1 - to_amt = self.rate.convert(from_amt, from_curr, to_curr) + to_amt = self.cost_rates.convert(from_amt, from_curr, to_curr) return "{} {} = {} {}".format( self.format_rate(from_amt), from_curr, self.format_rate(to_amt), to_curr, @@ -62,7 +64,7 @@ class Formatter: ) def format_conversion(self, from_amt, from_curr, to_curr): - to_amt = self.rate.convert(from_amt, from_curr, to_curr) + to_amt = self.cost_rates.convert(from_amt, from_curr, to_curr) return "{} = {}".format( self.format_currency(from_amt, from_curr), self.format_currency(to_amt, to_curr), @@ -70,6 +72,16 @@ class Formatter: class LedgerFormatter(Formatter): + COST_FMT = '{{={}}}' + PRICE_FMT = ' @ {}' + + def price_rate(self, from_amt, from_curr, to_curr): + if self.price_rates is None: + rates = self.cost_rates + else: + rates = self.price_rates + return rates.convert(from_amt, from_curr, to_curr) + def can_sign_currency(self, code): return len(babel.numbers.get_currency_symbol(code)) == 1 @@ -87,21 +99,42 @@ class LedgerFormatter(Formatter): qrate = rate return qrate.normalize() - def format_rate(self, rate): - return str(self.normalize_rate(rate)) - - def format_ledger_rate_raw(self, rate, curr): - rate_s = self.format_currency(rate, curr, currency_digits=False) - return "{{={0}}} @ {0}".format(rate_s) + def normalize_enough(self, rate, curr, from_amt, to_amt, prec=None): + if prec is None: + prec = self.rate_prec + # Starting from prec, find the least amount of precision to + # make sure from_amt converts exactly to to_amt. + for try_prec in itertools.count(prec): + try_rate = self.normalize_rate(rate, try_prec) + got_amt = self.currency_decimal(from_amt * try_rate, curr) + # If got_amt == to_amt, this is enough precision to do the + # conversion exactly, so we're done. + # If try_rate == rate, there's no more precision available, so stop. + if (got_amt == to_amt) or (try_rate == rate): + break + return try_rate - def format_ledger_rate(self, rate, curr): - return self.format_ledger_rate_raw(self.normalize_rate(rate), curr) + def _pretty_rate(self, fmt, rate, curr, from_amt=None, to_amt=None): + if to_amt is None: + rate = self.normalize_rate(rate) + else: + rate = self.normalize_enough(rate, curr, from_amt, to_amt) + return fmt.format(self.format_currency(rate, curr, currency_digits=False)) def format_rate_pair(self, from_curr, to_curr): from_amt = 1 - to_amt = self.rate.convert(from_amt, from_curr, to_curr) - return "{} {} {}".format( - from_amt, from_curr, self.format_ledger_rate(to_amt, to_curr)) + cost = self.cost_rates.convert(from_amt, from_curr, to_curr) + price = self.price_rate(from_amt, from_curr, to_curr) + if price is None: + price_s = '' + else: + price_s = self._pretty_rate(self.PRICE_FMT, price, to_curr) + return "{} {} {}{}".format( + from_amt, + from_curr, + self._pretty_rate(self.COST_FMT, cost, to_curr), + price_s, + ) def _denomination_for(self, currency, default): if self.denomination is None: @@ -116,22 +149,23 @@ class LedgerFormatter(Formatter): amt_s = self.format_currency(amount, currency) if denomination is None: return amt_s - full_rate = self.rate.convert(1, currency, denomination) - # Starting from self.rate_prec, find the least amount of precision to - # make sure the `from` amount converts exactly to the `to` amount. - to_amt = self.currency_decimal(amount * full_rate, denomination) - for prec in itertools.count(self.rate_prec): - rate = self.normalize_rate(full_rate, prec) - got_amt = self.currency_decimal(amount * rate, denomination) - # If got_amt == to_amt, this is enough precision to do the - # conversion exactly, so we're done. - # If rate == full_rate, there's no more precision available, so stop. - if (got_amt == to_amt) or (rate == full_rate): - break - return "{} {}".format(amt_s, self.format_ledger_rate_raw(rate, denomination)) + cost = self.cost_rates.convert(1, currency, denomination) + price = self.price_rate(1, currency, denomination) + to_amt = self.currency_decimal(amount * cost, denomination) + if price is None: + price_s = '' + else: + price_s = self._pretty_rate( + self.PRICE_FMT, price, denomination, amount, to_amt, + ) + return "{} {}{}".format( + amt_s, + self._pretty_rate(self.COST_FMT, cost, denomination, amount, to_amt), + price_s, + ) def format_conversion(self, from_amt, from_curr, to_curr): - to_amt = self.rate.convert(from_amt, from_curr, to_curr) + to_amt = self.cost_rates.convert(from_amt, from_curr, to_curr) return "{}\n{}".format( self.format_denominated_rate(from_amt, from_curr, to_curr), self.format_denominated_rate(to_amt, to_curr, None), @@ -147,19 +181,28 @@ class Formats(enum.Enum): return cls[s.upper()] +def load_rates(config, loaders, date): + with loaders.historical(date, config.args.base) as rate_json: + rates = oxrrate.Rate.from_json_file(rate_json) + if loaders.should_cache(): + config.cache.save_rate(rates) + return rates + def run(config, stdout, stderr): loaders = config.get_loaders() - with loaders.historical(config.args.date, config.args.base) as rate_json: - rate = oxrrate.Rate.from_json_file(rate_json) - if loaders.should_cache(): - config.cache.save_rate(rate) + cost_rates = load_rates(config, loaders, config.args.date) + if config.args.from_date is None: + price_rates = None + else: + price_rates = load_rates(config, loaders, config.args.from_date) formatter = config.args.output_format.value( - rate, + cost_rates, + price_rates, config.args.signed_currencies, denomination=config.args.denomination, ) if not config.args.from_currency: - for from_curr in sorted(rate.rates): + for from_curr in sorted(cost_rates.rates): print(formatter.format_rate_pair_bidir(from_curr, config.args.to_currency), file=stdout) elif config.args.amount is None: diff --git a/tests/historical2.json b/tests/historical2.json new file mode 100644 index 0000000000000000000000000000000000000000..2dea7617bfc36391a2b7408a74be2e58b9ab07a9 --- /dev/null +++ b/tests/historical2.json @@ -0,0 +1,13 @@ +{ + "disclaimer": "https://openexchangerates.org/terms/", + "license": "https://openexchangerates.org/license/", + "timestamp": 982256400, + "base": "USD", + "rates": { + "AED": 3.76246, + "ALL": 144.529739, + "ANG": 1.97, + "RUB": 57.0736, + "USD": 1 + } +} diff --git a/tests/test_historical.py b/tests/test_historical.py index a8988aa5b2efebf9da805ea0e9ebd84b543a0428..6ea9463befad285ea982fe3d60a38f34845d5ebd 100644 --- a/tests/test_historical.py +++ b/tests/test_historical.py @@ -1,6 +1,7 @@ import argparse import decimal import io +import itertools import json import re @@ -11,11 +12,11 @@ from . import any_date, relpath import oxrlib.commands.historical as oxrhist class FakeResponder: - def __init__(self, response_path): - self.response_path = response_path + def __init__(self, *response_paths): + self.paths = itertools.cycle(response_paths) def _respond(self, *args, **kwargs): - return open(self.response_path) + return next(self.paths).open() def __getattr__(self, name): return self._respond @@ -38,9 +39,16 @@ class FakeConfig: output = pytest.fixture(lambda: io.StringIO()) +@pytest.fixture(scope='module') +def single_responder(): + return FakeResponder(relpath('historical1.json')) + @pytest.fixture -def historical1_responder(): - return FakeResponder(relpath('historical1.json').as_posix()) +def alternate_responder(): + return FakeResponder( + relpath('historical1.json'), + relpath('historical2.json'), + ) def build_config( responder, @@ -48,6 +56,7 @@ def build_config( amount=None, from_currency=None, to_currency=None, + from_date=None, ledger=False, signed_currencies=None, denomination=None, @@ -59,6 +68,7 @@ def build_config( 'amount': None if amount is None else decimal.Decimal(amount), 'from_currency': from_currency, 'to_currency': base if to_currency is None else to_currency, + 'from_date': from_date, 'output_format': oxrhist.Formats['LEDGER' if ledger else 'RAW'], 'signed_currencies': [base] if signed_currencies is None else signed_currencies, 'denomination': denomination, @@ -86,8 +96,8 @@ def check_fx_amount(config, lines, amount, cost, fx_code, fx_sign=None, price=No line = next(lines, "") assert re.match(pattern, line) -def test_rate_list(historical1_responder, output, any_date): - config = build_config(historical1_responder, any_date) +def test_rate_list(single_responder, output, any_date): + config = build_config(single_responder, any_date) lines = lines_from_run(config, output) assert next(lines).startswith('1 AED = 0.27229') assert next(lines) == '1 USD = 3.67246 AED\n' @@ -96,52 +106,52 @@ def test_rate_list(historical1_responder, output, any_date): assert next(lines).startswith('1 ANG = 0.55865') assert next(lines) == '1 USD = 1.79 ANG\n' -def test_one_rate(historical1_responder, output, any_date): - config = build_config(historical1_responder, any_date, from_currency='ANG') +def test_one_rate(single_responder, output, any_date): + config = build_config(single_responder, any_date, from_currency='ANG') lines = lines_from_run(config, output) assert next(lines).startswith('1 ANG = 0.55865') assert next(lines) == '1 USD = 1.79 ANG\n' assert next(lines, None) is None -def test_conversion(historical1_responder, output, any_date): - config = build_config(historical1_responder, any_date, amount=10, from_currency='AED') +def test_conversion(single_responder, output, any_date): + config = build_config(single_responder, any_date, amount=10, from_currency='AED') lines = lines_from_run(config, output) assert next(lines) == '10.00 AED = 2.72 USD\n' assert next(lines, None) is None -def test_back_conversion(historical1_responder, output, any_date): - config = build_config(historical1_responder, any_date, +def test_back_conversion(single_responder, output, any_date): + config = build_config(single_responder, any_date, amount=2, from_currency='USD', to_currency='ALL') lines = lines_from_run(config, output) assert next(lines) == '2.00 USD = 289 ALL\n' assert next(lines, None) is None -def test_ledger_rate(historical1_responder, output, any_date): - config = build_config(historical1_responder, any_date, +def test_ledger_rate(single_responder, output, any_date): + config = build_config(single_responder, any_date, from_currency='ANG', ledger=True) lines = lines_from_run(config, output) check_fx_amount(config, lines, '1 ANG', '0.5586', 'USD', '$') check_fx_amount(config, lines, '1 USD', '1.79', 'ANG') assert next(lines, None) is None -def test_ledger_conversion(historical1_responder, output, any_date): - config = build_config(historical1_responder, any_date, +def test_ledger_conversion(single_responder, output, any_date): + config = build_config(single_responder, any_date, from_currency='ALL', amount=300, ledger=True) lines = lines_from_run(config, output) check_fx_amount(config, lines, '300 ALL', '0.00691', 'USD', '$') assert next(lines) == '$2.08\n' assert next(lines, None) is None -def test_signed_currencies(historical1_responder, output, any_date): - config = build_config(historical1_responder, any_date, +def test_signed_currencies(single_responder, output, any_date): + config = build_config(single_responder, any_date, from_currency='AED', ledger=True, signed_currencies=['EUR']) lines = lines_from_run(config, output) check_fx_amount(config, lines, '1 AED', '0.272', 'USD', '$') check_fx_amount(config, lines, '1 USD', '3.672', 'AED') assert next(lines, None) is None -def test_denomination(historical1_responder, output, any_date): - config = build_config(historical1_responder, any_date, +def test_denomination(single_responder, output, any_date): + config = build_config(single_responder, any_date, from_currency='ANG', to_currency='AED', amount=10, ledger=True, denomination='USD') lines = lines_from_run(config, output) @@ -149,8 +159,8 @@ def test_denomination(historical1_responder, output, any_date): check_fx_amount(config, lines, '20.52 AED', '0.272', 'USD', '$') assert next(lines, None) is None -def test_redundant_denomination(historical1_responder, output, any_date): - config = build_config(historical1_responder, any_date, +def test_redundant_denomination(single_responder, output, any_date): + config = build_config(single_responder, any_date, from_currency='ANG', to_currency='USD', amount=10, ledger=True, denomination='USD') lines = lines_from_run(config, output) @@ -158,8 +168,8 @@ def test_redundant_denomination(historical1_responder, output, any_date): assert next(lines) == '$5.59\n' assert next(lines, None) is None -def test_from_denomination(historical1_responder, output, any_date): - config = build_config(historical1_responder, any_date, +def test_from_denomination(single_responder, output, any_date): + config = build_config(single_responder, any_date, from_currency='USD', to_currency='ALL', amount=10, ledger=True, denomination='USD') lines = lines_from_run(config, output) @@ -167,8 +177,8 @@ def test_from_denomination(historical1_responder, output, any_date): check_fx_amount(config, lines, '1,445 ALL', '0.00691', 'USD', '$') assert next(lines, None) is None -def test_rate_precision_added_as_needed(historical1_responder, output, any_date): - config = build_config(historical1_responder, any_date, +def test_rate_precision_added_as_needed(single_responder, output, any_date): + config = build_config(single_responder, any_date, from_currency='RUB', to_currency='USD', amount=63805, ledger=True, denomination='USD') lines = lines_from_run(config, output) @@ -179,3 +189,21 @@ def test_rate_precision_added_as_needed(historical1_responder, output, any_date) check_fx_amount(config, lines, '63,805.00 RUB', '0.0175204', 'USD', '$') assert next(lines) == '$1,117.89\n' assert next(lines, None) is None + +def test_from_date_rates(alternate_responder, output, any_date): + config = build_config(alternate_responder, any_date, + from_currency='ANG', to_currency='AED', + from_date=any_date, ledger=True, denomination='USD') + lines = lines_from_run(config, output) + check_fx_amount(config, lines, '1 ANG', '2.051', 'AED', None, '1.909') + check_fx_amount(config, lines, '1 AED', '0.487', 'ANG', None, '0.523') + assert next(lines, None) is None + +def test_from_date_conversion(alternate_responder, output, any_date): + config = build_config(alternate_responder, any_date, + from_currency='ANG', to_currency='AED', amount=10, + from_date=any_date, ledger=True, denomination='USD') + lines = lines_from_run(config, output) + check_fx_amount(config, lines, '10.00 ANG', '0.558', 'USD', '$', '0.507') + check_fx_amount(config, lines, '20.52 AED', '0.272', 'USD', '$', '0.265') + assert next(lines, None) is None