def prepare_currency_data(): """ Prepare currency data for showing in the dropdown list by following steps: 1. Call get_rates() by USD, the output will be dictionary 2. Collect all keys into currency_list 3. Collect currency name by using keys in currency_list 4. return result :return currency list as dictionary """ # declare a returned parameter curr_list = {} # Prepare data: step 1 cr = CurrencyRates() exchange_rate = cr.get_rates('USD') # Prepare data: step 2 currency_code = list(exchange_rate.keys()) currency_code.append("USD") # Prepare data: step 3 cc = CurrencyCodes() for code in currency_code: curr_list[str(code)] = code + " - " + cc.get_currency_name(str(code)) # Prepare data: step 4 return curr_list
def currency_check(): source = [ 'GBP', 'HKD' 'IDR', 'ILS', 'DKK', 'INR', 'CHF', 'MXN', 'CZK', 'SGD', 'THB', 'THB', 'HRK', 'EUR', 'MYR', 'NOK', 'CNY', 'BGN', 'PHP', 'PLN', 'ZAR', 'CAD', 'ISK', 'BRL', 'RON', 'NZD', 'TRY', 'JPY', 'RUB', 'KRW', 'USD', 'AUD', 'HUF', 'SEK' ] origin = request.form['origin'].upper() travel = request.form['travel'].upper() amount = int(request.form['amount']) print(origin not in source) # print(origin) # print(type(origin)) if origin not in source: flash(f'{origin} input not valid') return redirect('/') elif travel not in source: flash(f'{travel} input not valid') return redirect('/') else: c = CurrencyRates() currency_change = c.get_rates(origin)[travel] currency_final = currency_change * amount c_code = CurrencyCodes() currency_code = c_code.get_symbol(travel) return render_template('currency.html', origin=origin, travel=travel, amount=amount, currency_code=currency_code, currency_final=currency_final)
def __get_currency_code_and_symbol(self, currency): """ Checks the currency code, then the symbol and returns the ode and the symbol :return: The currency code and currency symbol (if set, otherwise None) """ # Load the currency codes cc = CurrencyCodes() if cc.get_symbol(currency) is None: # Currency code (e.g. EUR) is not recognized if cc.get_currency_code_from_symbol(currency) is None: # Currency symbol (e.g. $) is not recognized print("Currency " + currency + " not recognized.") sys.exit(1) else: # Currency symbol recognized file_path = os.path.dirname(os.path.abspath(__file__)) with open(file_path + '/raw_data/currencies_symbols.json') as f: self.currencies_symbols = json.loads(f.read()) # Saves the list of codes for given symbol to variable codes_for_symbol = self.get_codes_for_symbol(currency) if codes_for_symbol is None: # The symbol is valid just for one currency # Returns the currency code and symbol return cc.get_currency_code_from_symbol(currency), currency else: # The symbol is valid for multiple currencies # Returns the first currency code from the list and the currency symbol return codes_for_symbol[0], currency # Returns currency code and no symbol (was not set) return currency, None
class Currency(): def __init__(self): self.c = CurrencyRates() self.currency_codes = self.c.get_rates('USD').keys() self.symbols = CurrencyCodes() def validate_code(self, start, end, amount): """Return entered currency code if the input is invalid""" start_err = False end_err = False amount_err = False if start.upper() not in self.currency_codes: start_err = True if end.upper() not in self.currency_codes: end_err = True try: Decimal(amount) except: amount_err = True return start_err, end_err, amount_err def calculate_currency(self, start, end, amount): """Calculate the currency and return the currency with its given symbol""" start = start.upper() end = end.upper() converted_amount = self.c.convert(start, end, Decimal(amount)) converted_amount = '%.2f' % converted_amount symbol = self.symbols.get_symbol(end) currency_name_start = self.symbols.get_currency_name(start) currency_name_end = self.symbols.get_currency_name(end) symbol_and_amount = symbol + " " + converted_amount return currency_name_start, symbol_and_amount, currency_name_end
def test_currency_symbol(self): """Test for currency_symbol() method in Currency class.""" init = 'USD' c2 = CurrencyCodes() c_symbol = c2.get_symbol(init) self.assertEqual(c_symbol, 'US$')
def rate(): if not is_form_valid(request.args): flash("Make sure all fields are filled") return redirect("/") currency_from = request.args.get('from') currency_to = request.args.get('to') amount = float(request.args.get('amount')) codes = CurrencyCodes() if not is_code_valid(currency_from) or not is_code_valid(currency_to): flash_invalid_currencies(currency_from, currency_to) return redirect("/") print("party over here") result = run_conversion(currency_from, currency_to, amount) token = codes.get_symbol(currency_to) token_from = codes.get_symbol(currency_from) return render_template("/result.html", token=token, result=result, token_from=token_from, amount=amount)
def get_currency_symbol(currency_code): curr_codes = CurrencyCodes() symbol = curr_codes.get_symbol(currency_code) if symbol == None: return "" else: return symbol
def convert(): cr = CurrencyRates() cc = CurrencyCodes() from_currency = request.form["from_currency"].upper() to_currency = request.form["to_currency"].upper() valid_from_cn = cc.get_currency_name(from_currency) valid_to_cn = cc.get_currency_name(to_currency) symbol = cc.get_symbol(to_currency) try: amount = float(request.form["amount"]) except: amount = None try: result = cr.convert(from_currency, to_currency, amount) except: if valid_from_cn == None: flash(f"Currency unavailable: {from_currency}") # return render_template("/index.html") if valid_to_cn == None: flash(f"Currency unavailable: {to_currency}") # return render_template("/index.html") if amount == None: flash("Please enter valid amount.") # return render_template("/index.html") return render_template("/index.html") return render_template("/results.html", symbol=symbol, result=round(result,2), from_currency=from_currency, to_currency=to_currency)
def currency_convertor(request): c = CurrencyRates() s = CurrencyCodes() currency_list = { 'USD', 'EUR', 'JPY', 'GBP', 'AUD', 'CAD', 'CHF', 'CNY', 'SEK', 'NZD', 'MXN', 'SGD', 'HKD', 'INR' } if request.method == "POST": trade_size1_3 = request.POST['trade_size1_3'] if trade_size1_3 is '': trade_size1_3 = 1 else: trade_size1_3 = float(trade_size1_3) cur_1 = request.POST['sel1_1'] cur_2 = request.POST['sel1_2'] if cur_2 == cur_1: cur_2 = 'INR' cur_1 = 'USD' symbol = s.get_symbol(cur_2) rate = c.get_rate(cur_1, cur_2) value = rate * trade_size1_3 one = 1 return render( request, 'currency_convertor.html', { 'currencyList': currency_list, 'value': value, 'symbol': symbol, 'from_currency': cur_1, 'to_currency': cur_2, 'rate': rate, 'one': one }) return render(request, 'currency_convertor.html', {'currencyList': currency_list})
def check_currency_code(currency_code): c = CurrencyCodes() if c.get_currency_name(currency_code) is None: return False return True
def home(): """Default home route with conversion form""" form = CurrencyForm() if form.validate_on_submit(): session.clear() convert_from = form.convert_from.data.upper() convert_to = form.convert_to.data.upper() amount = form.amount.data cc = CurrencyCodes() for curr in (convert_from, convert_to): if not cc.get_currency_name(curr): flash(f'Incorrect currency code: {curr}', 'error') return redirect(url_for('home')) if amount < 1: flash('Not a valid amount', 'error') return redirect(url_for('home')) symbol = cc.get_symbol(convert_to) cr = CurrencyRates() session['symbol'] = symbol session[ 'amount'] = f"{cr.convert(convert_from, convert_to, amount):.2f}" return redirect(url_for('converted')) else: return render_template('home.html', form=form)
def getConversionRate(fromcur, tocur, amount): c = CurrencyRates() codes = CurrencyCodes() converted = c.convert(fromcur, tocur, amount) fromSymbol = codes.get_symbol(fromcur) toSymbol = codes.get_symbol(tocur) conversion_result = "%s %0.2f = %s %0.2f" % (fromSymbol, amount, toSymbol, converted) return conversion_result
def supported_currencies(self): currency_rates = CurrencyRates() # get all supported currencies from Forex codes = dict(currency_rates.get_rates('USD')) symbols = CurrencyCodes() codes['USD'] = '' # get symbols for supported currencies for code in codes.keys(): codes[code] = symbols.get_symbol(code) return codes
def __init__(self): self.cr = CurrencyRates() self.codes = CurrencyCodes() self.curr_codes = [ 'EUR', 'IDR', 'BGN', 'ILS', 'GBP', 'DKK', 'CAD', 'JPY', 'HUF', 'RON', 'MYR', 'SEK', 'SGD', 'HKD', 'AUD', 'CHF', 'KRW', 'CNY', 'TRY', 'HRK', 'NZD', 'THB', 'USD', 'NOK', 'RUB', 'INR', 'MXN', 'CZK', 'BRL', 'PLN', 'PHP', 'ZAR' ] self.results = {'frm': '', 'to': '', 'amount': ''}
def flash_conversion(firstCurr, secondCurr, amount): s = CurrencyCodes() c = CurrencyRates() symbol = s.get_symbol(secondCurr) result = c.convert(firstCurr, secondCurr, Decimal(amount)) formatted_result = "{:,.2f}".format(result) flash_message = f'{symbol} {formatted_result}' flash(flash_message, 'success')
def convert_curr(curr1, curr2, amount): currencies = {'1':'USD', '2':'EUR', '3':'RUB'} symb = CurrencyCodes() c = CurrencyRates() result = round(c.convert(currencies[curr1], currencies[curr2], amount), 2) symb_curr1 = symb.get_symbol(currencies[curr1]) symb_curr2 = symb.get_symbol(currencies[curr2]) return "\t{} {} to {} is {} {}".format(amount, symb_curr1, currencies[curr2], result, symb_curr2)
def __init__(self, convert_from, convert_to, amount): """This method Converts from one currency to another given the amount""" self.convert_from = convert_from.upper() self.convert_to = convert_to.upper() self.amount = amount self.supported_currency_codes = ["EUR", "IDR", "BGN", "ILS", "GBP", "DKK", "CAD", "JPY", "HUF", "RON", "MYR", "SEK", "SGD", "HKD", "AUD", "CHF", "KRW", "CNY", "TRY", "HRK", "NZD", "THB", "USD", "NOK", "RUB", "INR", "MXN", "CZK", "BRL", "PLN", "PHP", "ZAR"] self.c = CurrencyRates() self.cc = CurrencyCodes()
def get_symbol(code): """ Get the symbol of currency code >>> get_symbol("USD") 'US$' >>> get_symbol("ABC") """ c = CurrencyCodes() return c.get_symbol(code)
def country_currency_code(lb_country): country_name = lb_country.strip() for currency, data in moneyed.CURRENCIES.iteritems(): if country_name.upper() in data.countries: symb = CurrencyCodes() symbol = symb.get_symbol(str(currency)) new_symbol = symbol if new_symbol == "None": return currency else: return symbol
class TestCurrencySymbol(TestCase): """ test currency symbols from currency codes """ def setUp(self): self.c = CurrencyCodes() def test_with_valid_currency_code(self): self.assertEqual(str(self.c.get_symbol('USD')), 'US$') def test_with_invalid_currency_code(self): self.assertFalse(self.c.get_symbol('XYZ'))
class TestCurrencySymbol(TestCase): """ test currency symbols from currency codes """ def setUp(self): self.c = CurrencyCodes() def test_with_valid_currency_code(self): self.assertEqual(str(self.c.get_symbol('USD')), 'US$') def test_with_invalid_currency_code(self): self.assertFalse(self.c.get_symbol('XYZ'))
def convert(amount_from, amount_to, amount): """ converts from USD to INR >>> convert('USD','INR',10) ₹ 725.06 """ currency = CurrencyRates() codes=CurrencyCodes() result = currency.convert(amount_from, amount_to, int(amount)) result = str(round(result, 2)) return codes.get_symbol(amount_to) + ' ' + result
def currency_code_and_symbol(self, code_or_symbol): if code_or_symbol.upper() in ('BTC', '₿'): return 'BTC', '₿' c = CurrencyCodes() code = c.get_currency_code_from_symbol(code_or_symbol) if code: return code, code_or_symbol code_or_symbol = code_or_symbol.upper() symbol = c.get_symbol(code_or_symbol) if symbol: return code_or_symbol, symbol return None
class TestCurrencyName(TestCase): """ test currency name from currency codes """ def setUp(self): self.c = CurrencyCodes() def test_with_valid_currency_code(self): self.assertEqual(str(self.c.get_currency_name('USD')), 'United States dollar') def test_with_invalid_currency_code(self): self.assertFalse(self.c.get_currency_name('XYZ'))
def form_handler(): fromCurr = request.form.get('fromCurr') toCurr = request.form.get('toCurr') amt = request.form.get('amt') to_curr_symbol = CurrencyCodes().get_symbol(toCurr) from_curr_symbol = CurrencyCodes().get_symbol(fromCurr) resAmt = converter(fromCurr, toCurr, amt) return render_template( 'index.html', currency=currencys, result= f"You could get {to_curr_symbol}{resAmt} {toCurr} with {from_curr_symbol}{amt} {fromCurr}" )
class TestCurrencyName(TestCase): """ test currency name from currency codes """ def setUp(self): self.c = CurrencyCodes() def test_with_valid_currency_code(self): self.assertEqual(str(self.c.get_currency_name('USD')), 'United States dollar') def test_with_invalid_currency_code(self): self.assertFalse(self.c.get_currency_name('XYZ'))
def curr_codes(): cn = CurrencyCodes() from_curr = entry1.get() #Currency to be converted to_curr = entry2.get() #Currency to be converted In new_code = cn.get_currency_name(from_curr) new_code1 = cn.get_currency_name(to_curr) final_codes.delete(0, tk.END) final_codes.insert(0, str(new_code)) final_codes.insert(20, str(" to ")) final_codes.insert(25, str(new_code1)) final_codes.insert(45, str(" Conversion."))
def converter_forex_python(coin, amount, Cdict, dict_rate2): if amount <= 0: return 0 coin = coin.upper() try: if coin in Cdict.keys(): return amount / Cdict.get(coin) else: symbolDict = dict() symbol = CurrencyCodes() for key in Cdict.keys(): symbolDict[symbol.get_symbol(key)] = key return amount / Cdict.get(symbolDict.get(coin)) except: return converter_fixerio(coin, amount,dict_rate2)
def __init__(self): self.currency_rates_last_update = time.time() self.currency_rates = self._get_all_currency_rates() self.currency_codes = CurrencyCodes() self.currency_shortcuts_to_symbols = {} self.request_currency_shortcuts_and_symbols() self.currency_symbols = [ currency_symbol for currency_symbol in self.currency_shortcuts_to_symbols.values() ] self.currency_shortcuts = [ currency_shortcut for currency_shortcut in self.currency_shortcuts_to_symbols.keys() ]
def main(): print("*" * 60) print("Welcome to Currency Converter") CRate, CCode = CurrencyRates(), CurrencyCodes() k = 1 while input("Continue? (Y/N): ").upper() == 'Y': print("=" * 25 + " Round " + str(k) + ' ' + "=" * 25) # Input amount = input("Enter the amount you wish to convert: ") base = input("Input the base currency: ").upper() target = input("Input the target currency: ").upper() try: result = CRate.convert(base, target, float(amount)) print("{} {}({}) is {} {}({})".format(amount, base, CCode.get_symbol(base), round(result, 2), target, CCode.get_symbol(target))) except RatesNotAvailableError: print( 'The base or target currency are not supported, please refer to ' 'https://forex-python.readthedocs.io/en/latest/currencysource.html' ) except ValueError: print('Please enter correct amount! Only number!') print("=" * 60, '\n') k += 1 print("*" * 60) print("Thanks for your support! Welcome come to use next time!")
def validate_ticker(ctx, param, value): try: if re.fullmatch(r"^[A-Z]{3}$", value): # Проверяем соответствует ли тикер формату c = CurrencyCodes() if c.get_currency_name( value): # Если можем получить название по тикеру return value # то выходим, иначе бросаем эксепшн else: raise BadParameter('такого тикера нет') else: raise BadParameter('тикер не соответствует формату ААА') except BadParameter as error: # В случае ошибки click.echo(f'Ошибка: {error}') # выводим ее value = click.prompt(param.prompt) # и делаем магию с колбэками return validate_ticker(ctx, param, value) # которую возвращаем обратно
def test_currency_name(self): """Test for currency_name() method in Currency class.""" init = 'USD' curr = Currency(init) c2 = CurrencyCodes() self.assertEqual(curr.currency_name, 'United States dollar')
def setUp(self): self.c = CurrencyCodes()
import xml.etree.ElementTree as ET from decimal import * import collections from sopel.module import commands, example, NOLIMIT from sortedcontainers import SortedDict from forex_python.converter import CurrencyCodes from forex_python.converter import CurrencyRates from forex_python.bitcoin import BtcConverter from pymarketcap import Pymarketcap from coinmarketcap import Market import coinmarketcap c = CurrencyRates() b=BtcConverter() m=Market() cc=CurrencyCodes() allcoins={} curlist=list(c.get_rates("USD").keys()) #print(c.get_rates("USD")) curlist.append("USD") curlist.sort() for cur in curlist: allcoins[cur]=cc.get_currency_name(cur) altcoinmap={} #print (coinmarketcap.price("BTC")) json=m.ticker(convert='EUR') #print(json) for currency in json: altcoinmap[currency["symbol"]]=currency["id"] allcoins[currency["symbol"]]=currency["name"] #print(altcoinmap) #print(json)