def test_derives_missing_inverse_rates(self): rates = [ {"from": "FOO", "to": "BAR", "conversion": Decimal("1.23")}, {"from": "BAR", "to": "BAZ", "conversion": Decimal("0.95")}, {"from": "BAZ", "to": "QUX", "conversion": Decimal("1.11")}, {"from": "BAT", "to": "QUX", "conversion": Decimal("1.01")}] converter = Rates(rates) self.assertEqual(converter.conversion("FOO", "BAT"), Decimal("1.2842"))
def get_sum_in_currency(currency): amount = 0 cash = Wallet().get() for curr in cash: amount += cash[curr] * (1 if curr == currency else get_rate_ratio( Rates().get(curr), Rates().get(currency))) return amount
def setUp(self): """ Ensures that `utils.pog_converter.PogConverter.__init__` is not executed when `from rates import Rates` Occurs, which would erroneously report that `rates.Rates.__init__` has been covered when just running pytest on `test_rates.py` """ with mock.patch("rates.Rates.__init__") as RatesInit: RatesInit.return_value = None from rates import Rates self.rates = Rates()
def __init__(self, currencies): self.args = vars(parse_init_params()) set_logger_options(self.args['debug']) logger.info('Starting app ...') self.rate = Rates(['EUR', 'USD']) cash = {} for currency in currencies: if currency in self.args: cash[currency] = self.args[currency] self.wallet = Wallet(cash)
def get_wallet_statement(): cash = Wallet().get() text = '' for currency in cash: text += '{}: {}\n'.format(currency, cash[currency]) text += '\n' for currency in cash: if currency.lower() != 'rub': text += 'rub-{}: {}\n'.format(currency.lower(), Rates().get(currency)) else: text += 'usd-eur: {}\n'.format( get_rate_ratio(Rates().get('eur'), Rates().get('usd'))) text += '\n' text += 'sum:' for currency in cash: text += ' {} {} /'.format(currency, get_sum_in_currency(currency)) return text[:-2]
def test_init(self, parse_csv): """ Only import within the scope of this test so that subsequent tests can remove the __init__ call, ensuring the __init__ lines and the functions invoked therein are properly unit tested """ from rates import Rates self.rates = Rates() assert self.rates.currency_to_series_id == {} assert self.rates.series == {} assert self.rates.observations == {} parse_csv.assert_called_once()
from argparser import get_args from inputs import get_year_input, get_month_input, get_currency_input from rates import Rates args = get_args() rates = Rates() def main(): print("Welcome to the Historical Rate Calculator") year = args.year if args.year else get_year_input(rates) month = args.month if args.month else get_month_input(rates) currency = args.currency if args.currency else get_currency_input(rates) conversion_rate = rates.get_rate(year, month, currency) print(f"Conversion rate of {currency} to CAD: {conversion_rate}") if __name__ == "__main__": main()
from rates import Rates if __name__ == '__main__': rates = Rates() print('Print "%currency%=%amount%" to get exchange rates\n' 'Print "Add ABC/DEF=xxx" to add exchange rate or check existing one\n' 'print "Save" to permanently save changes\n' 'print "Exit" to quit an application') while True: request = input('Enter your request\n') if '/' in request and '=' in request: rates.change_rate(request.split('=')[0], float(request.split('=')[1])) elif '=' in request: rates.print_rates(request.split("=")[0], float(request.split("=")[1])) elif request == 'Exit': break elif request == 'Save': rates.save_rates() else: print('Incorrect request')
class Test_Rates(TestCase): def setUp(self): """ Ensures that `utils.pog_converter.PogConverter.__init__` is not executed when `from rates import Rates` Occurs, which would erroneously report that `rates.Rates.__init__` has been covered when just running pytest on `test_rates.py` """ with mock.patch("rates.Rates.__init__") as RatesInit: RatesInit.return_value = None from rates import Rates self.rates = Rates() @mock.patch("csv.reader") @mock.patch("builtins.open", new_callable=mock.mock_open, read_data="data") def test_parse_csv(self, mock_open, csv_reader): mock_csv_contents = [ ["STUFF"], [], [], ["THAT"], [], ["SHOULD BE IGNORED"], [], [], ["SERIES"], ["id", "label", "description"], ["somefakeid", "AUD/CAD", "AUD to CAD"], ["anotherfakeid", "JPY/CAD", "JPY to CAD"], ["onemorefakeid", "EUR/CAD", "EUR to CAD"], [], ["OBSERVATIONS"], ["date", "somefakeid", "anotherfakeid", "onemorefakeid"], ["2017-01-01", 1.00, 0.50, 0.25], ["2018-01-01", 0.50, 0.25, 0.125], ["2019-01-01", 0.75, 0.33, 0.15], [], ] real_csv_filename = "FX_RATES_MONTHLY-sd-2017-01-01.csv" csv_reader.return_value = mock_csv_contents self.rates.currency_to_series_id = {} self.rates.series = {} self.rates.observations = {} self.rates.parse_csv() mock_open.assert_called_once_with(real_csv_filename) csv_reader.assert_called_once_with(mock_open.return_value) assert self.rates.series == { "somefakeid": { "label": "AUD/CAD", "description": "AUD to CAD" }, "anotherfakeid": { "label": "JPY/CAD", "description": "JPY to CAD" }, "onemorefakeid": { "label": "EUR/CAD", "description": "EUR to CAD", }, } assert self.rates.currency_to_series_id == { "AUD": "somefakeid", "JPY": "anotherfakeid", "EUR": "onemorefakeid", } assert self.rates.observations == { 2017: { 1: { "somefakeid": 1.0, "anotherfakeid": 0.5 } }, 2018: { 1: { "somefakeid": 0.5, "anotherfakeid": 0.25 } }, 2019: { 1: { "somefakeid": 0.75, "anotherfakeid": 0.33 } }, } def test_get_supported_years(self): mock_supported_years = [2017, 2018, 2019] self.rates.observations = {} for year in mock_supported_years: self.rates.observations[year] = {} assert self.rates.get_supported_years() == mock_supported_years def test_get_supported_currencies(self): mock_supported_currencies = ["AUD", "EUR", "JPY"] self.rates.currency_to_series_id = {} for currency in mock_supported_currencies: self.rates.currency_to_series_id[currency] = {} assert ( self.rates.get_supported_currencies() == mock_supported_currencies) @mock.patch("rates.Rates.get_supported_years") def test_check_valid_year_input_valid_year(self, get_supported_years): captured_error = None get_supported_years.return_value = [2017, 2018, 2019] try: self.rates.check_valid_year(get_supported_years.return_value[0]) except Exception as err: captured_error = err get_supported_years.assert_called_once() assert captured_error == None @mock.patch("rates.Rates.get_supported_years") def test_check_valid_year_input_invalid_year(self, get_supported_years): get_supported_years.return_value = [2017, 2018, 2019] inputted_year = 2016 captured_error = None try: self.rates.check_valid_year(inputted_year) except Exception as err: captured_error = err get_supported_years.assert_called_once() assert str(captured_error) == ( f"Unsupported year: {inputted_year}\n" f"Supported years include: {get_supported_years.return_value}") def test_check_valid_month_input_valid_month(self): captured_error = None try: self.rates.check_valid_month(1) except Exception as err: captured_error = err assert captured_error == None def test_check_valid_month_input_invalid_month(self): captured_error = None inputted_month = 0 try: self.rates.check_valid_month(inputted_month) except Exception as err: captured_error = err assert str(captured_error) == (f"Invalid month: {inputted_month}\n" f"Month must be a value between 1-12") @mock.patch("rates.Rates.get_supported_currencies") def test_check_valid_currency_input_valid_currency( self, get_supported_currencies, ): inputted_currency = "AUD" get_supported_currencies.return_value = [inputted_currency] captured_error = None try: self.rates.check_valid_currency(inputted_currency) except Exception as err: captured_error = err get_supported_currencies.assert_called_once() assert captured_error == None @mock.patch("rates.Rates.get_supported_currencies") def test_check_valid_currency_input_invalid_currency( self, get_supported_currencies, ): inputted_currency = "JPY" get_supported_currencies.return_value = ["AUD"] captured_error = None try: self.rates.check_valid_currency(inputted_currency) except Exception as err: captured_error = err get_supported_currencies.assert_called_once() assert str(captured_error) == ( f"Unsupported currency: {inputted_currency}\n" f"Supported currencies include: " f"{get_supported_currencies.return_value}") @mock.patch("rates.Rates.check_valid_year") @mock.patch("rates.Rates.check_valid_month") @mock.patch("rates.Rates.check_valid_currency") def test_get_rate( self, check_valid_currency, check_valid_month, check_valid_year, ): year = 2017 month = 1 currency = "AUD" series_id = "somefakeid" mock_rate = 1.00 self.rates.currency_to_series_id = { currency: series_id, } self.rates.observations = {year: {month: {series_id: mock_rate}}} returned_rate = self.rates.get_rate(year, month, currency) check_valid_currency.assert_called_once() check_valid_month.assert_called_once() check_valid_year.assert_called_once() assert (returned_rate == self.rates.observations[year][month][series_id] and returned_rate == mock_rate)
maxAverageDiameterThreshold = args.maxAverageDiameterThreshold # call samplegenerator which calls RNAxplorer (in matrix2d objects) and executes a clustering (2D or DIANA, etc.) only to select # new structure representatives for samplegeneration. structures = samplegenerator.mainloop(twoDSamplingParameters) # call final clusteralg. clusters = DIANA.doClustering(structures, maxDiameterThreshold, maxAverageDiameterThreshold) DIANA.printClusters(clusters) representatives = selectRepresentatives(seq, clusters) # prepare representatives and sort them, to make the comparison of the output easier. repsAndEnergies = [(x, RNA.energy_of_struct(seq, x)) for x in representatives] repsAndEnergies.sort(key=operator.itemgetter(1, 0)) # rate computation. rateMatrix = Rates.arrheniusRates(seq, repsAndEnergies) # write files for treekin (matrix and structures) fw = filewriter.FileWriter() fw.writeMatrixToFile(rateMatrix, param.RatesFilePath) fw.writeRepresentativesToFile(seq, repsAndEnergies, param.StructuresFilePath) # run treekin to_call = "cat " + param.StructuresFilePath + " | treekin --p0 " + str(param.StartStructureID) + "=1 --ratesfile " + param.RatesFilePath + " --t0 " + \ str(param.StartTime) + " --t8 " + str(param.EndTime) + " -m I > " + param.KineticFile os.system(to_call)
from pandas.tseries.offsets import BDay import pandas as pd import matplotlib.pyplot as plt import logging import os import sys from datetime import date, datetime, timedelta from functools import wraps import re logging.basicConfig(level=logging.WARNING) logger = logging.getLogger(__name__) rates = Rates(caching_period_minutes=10) def timed_rates_update(func): """Декоратор обновляющий кеш котировок""" @wraps(func) def _wrapped(*args, **kwargs): global rates rates.update_rates_cache() return func(*args, **kwargs) return _wrapped def get_rates(): """Возвращает форматированный список котировок"""
def print_usage(): print("""Usage: value currency : conversion, e.g.: 10 USD currency_from / currency_to = value : to set rate, e.g.: USD/RUB=66 q : exit """) def main_loop(): print_usage() cmd = "" while cmd.strip() not in ['q', 'Q']: print("> ") cmd = input() args = cmd.strip().split() if len(args) == 2: # assuming it is, e.g. 10 USD rates.calc(args[0], args[1]) elif '=' in cmd: rates.parseRate(cmd) else: print_usage() rates.save() # ======== Execution ============= if __name__ == "__main__": from rates import Rates rates = Rates(" USD/RUR=64.35 BTC/RUR=325960 USD/EUR=0.88 EUR/RUR=72.72") main_loop()