class TestGetRates(TestCase): """ Test get_rates with valid(ex: USD) and invalid(ex: XYZ) currency code """ def setUp(self): self.c = CurrencyRates() def test_get_rates_valid_code(self): all_rates = self.c.get_rates('USD') # Check if return value of get_rates dictionary self.assertTrue(isinstance(all_rates, dict)) # Test at least one rate value returned self.assertTrue(len(all_rates.keys())) # Test one rate in returned dict is float value self.assertTrue(isinstance(all_rates.get('INR'), float)) def test_get_rates_with_date(self): date_obj = datetime.datetime.strptime('2010-05-10', "%Y-%m-%d").date() all_rates = self.c.get_rates('USD', date_obj) # Check if return value of get_rates dictionary self.assertTrue(isinstance(all_rates, dict)) # Test at least one rate value returned self.assertTrue(len(all_rates.keys())) # Test one rate in returned dict is float value self.assertTrue(isinstance(all_rates.get('INR'), float)) def test_get_rates_invalid_code(self): self.assertRaises(RatesNotAvailableError, self.c.get_rates, 'XYZ')
def get_currency_daily_price(end_date,currency_type): if not type(currency_type) is list: print("currency_type data error!!exit!!") exit() USD_csv_file="./currency_daily_data/USD_price.csv" EUR_csv_file="./currency_daily_data/EUR_price.csv" GBP_csv_file="./currency_daily_data/GBP_price.csv" CNY_csv_file="./currency_daily_data/CNY_price.csv" AUD_csv_file="./currency_daily_data/AUD_price.csv" start_date=datetime(2000,1,1) #start_date=datetime(2017,1,1) # for test end_date=datetime.today() date_range=daterange(start_date,end_date) #print(date_range) c=CurrencyRates() #currency_data=pd.DataFrame() print(currency_type) #if type(currency_type) is list: #currency_data.columns=currency_type for data_type in currency_type: array_data={"date":[],"rate":[]} if data_type =="USD": csv_file=USD_csv_file elif data_type == "EUR": csv_file=EUR_csv_file elif data_type== "GBP": csv_file=GBP_csv_file elif data_type== "CNY": csv_file=CNY_csv_file elif data_type=="AUD": csv_file=AUD_csv_file else: print("currency_type not specified!!please check again!!") exit() for date in date_range: #print(date) data=c.get_rate(currency_type,"JPY",date) #print(data) #if not currency_type in currency_data.columns.values(): #currency_data.columns.append(currency_type) array_data["date"].append(date) array_data["rate"].append(data) #print(array_data.values()) #currency_data=pd.DataFrame(list(array_data.items()),columns=["date","rate"]) currency_data=pd.DataFrame({"date":array_data["date"],"rate":array_data["rate"]}) print(currency_data) gen_currency_csv_file(currency_data,csv_file) print(currency_data)
def jpdTohkd(): # get currency rate for JPY # currentJPY = 0.07122 c = CurrencyRates() currentJPY = c.get_rate('JPY','HKD') datetimeStr = datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S') g1 = jpy2hkd.Group("100", 100, 1000, 50, 100, currentJPY) g2 = jpy2hkd.Group("1000", 1000, 5000, 100, 1000, currentJPY) # g2 = jpy2hkd.Group("2000", 2000, 3000, 100, 1000, currentJPY) # g2 = jpy2hkd.Group("3000", 3000, 4000, 100, 1000, currentJPY) # g2 = jpy2hkd.Group("4000", 4000, 5000, 100, 1000, currentJPY) g3 = jpy2hkd.Group("5000", 5000, 10000, 100, 1000, currentJPY) main = jpy2hkd.jpy2hkd() main.AddGroup("100",g1) main.AddGroup("1000",g2) main.AddGroup("5000",g3) jpy = 100 hkd = round(currentJPY * jpy,1) errors = [] if request.method == "POST": try: jpy_in = request.form.get('jpy_in') hkd_in = request.form.get('hkd_in') if jpy_in is not None: jpy = float(jpy_in) if jpy != 0: hkd = jpy*currentJPY hkd = round(hkd,1) if hkd_in is not None: hkd = float(hkd_in) if hkd != 0: jpy = hkd/currentJPY jpy = round(jpy,1) except: errors.append("Unable to get URL.") disCurrnetJPY = round((currentJPY*100),2) return render_template( "jpy2hkd.html", main = main, jpy = jpy, hkd = hkd, currentJPY = disCurrnetJPY, datetimeStr = datetimeStr)
def getHistoricalXRatesForDate(dateObj): dateStart = dateObj dateEnd = dateStart dataBtc = quandl.get(["BCHARTS/KRAKENUSD.4"], start_date=dateStart, end_date=dateEnd, returns="numpy") if dataBtc.size > 0: btcUsdClosePrice = dataBtc[0][1] else: statusMsg = "ERROR - BTC/USD close price not found for date {0} !".format(dateStart) writeOutputParms(statusMsg, '0', '0') sys.exit(1) cr = CurrencyRates() usdChfRate = cr.get_rate('USD', 'CHF', dateObj) return float(btcUsdClosePrice), float(usdChfRate)
def currencyconv(self, jarvis, amount, fr, to): """ currencyconv converts the given amount to another currency using fore-python """ b = BtcConverter(force_decimal=True) c = CurrencyRates(force_decimal=True) if (to == "BTC"): result = b.convert_to_btc(Decimal(amount), fr) elif (fr == "BTC"): result = b.convert_btc_to_cur(Decimal(amount), to) else: result = c.convert(fr, to, Decimal(amount)) outputText = str(amount) + " " + fr + \ " are equal to " + str(result) + " " + to jarvis.say(outputText)
def main(config, push_to_server=False): c = CurrencyRates() # Will raise RatesNotAvailableError if not able to fetch from the api usd_to_sek = c.get_rate('USD', 'SEK') eur_to_sek = c.get_rate('EUR', 'SEK') # Create the doc that will be uploaded doc = {} doc['Issued at'] = datetime.datetime.now().isoformat() # I know it's bad practice to call the _source_url method, # but if it breaks it breaks. doc['Data source'] = "forex_python ({})".format(c._source_url()) doc['USD_in_SEK'] = usd_to_sek doc['EUR_in_SEK'] = eur_to_sek # Load the statusdb database with open(config) as settings_file: server_settings = yaml.load(settings_file) couch = Server(server_settings.get("couch_server", None)) db = couch['pricing_exchange_rates'] # Check that new is not too strange compared to current. # This is a safety measure so that we have lower risk of having erroneus # exchange rates in the db. current_usd = get_current(db, 'usd_to_sek') current_eur = get_current(db, 'eur_to_sek') check_financial_crisis(current_usd, usd_to_sek, 'USD') check_financial_crisis(current_eur, eur_to_sek, 'EUR') # Completely conserved currencies are also strange. if (current_eur is not None) and (current_usd is not None): # This assumes the script is not ran too often # (api udpates once per day) small_number = 0.0000000001 if (abs(current_usd - usd_to_sek) < small_number) and \ (abs(current_eur - eur_to_sek) < small_number): raise Exception("Super stable currencies? Stale api would be my guess.") if push_to_server: db.save(doc) else: print(doc)
def _load_forex(start=date(2015, 1, 1), end=date.today(), currency_1='USD', currency_2='EUR'): """Load forex dataset.""" cr = CurrencyRates() def get_rate(day): time.sleep(0.1) return cr.get_rate(currency_1, currency_2, day) return _fetch(get_rate, start=start, end=end)
def get_output_rates(amount, input_currency, output_currency): currency_rates = CurrencyRates() if output_currency: if input_currency == output_currency: converted_amount = amount else: converted_amount = currency_rates.convert(input_currency.code, output_currency.code, amount) output = {output_currency.code: converted_amount} else: latest_rates_for_input_currency = currency_rates.get_rates( input_currency.code) for code, value in latest_rates_for_input_currency.items(): latest_rates_for_input_currency[code] = value * amount output = latest_rates_for_input_currency return output
def RealTimeCurrencyConversion(): c = CurrencyRates() from_currency = ip1.get() to_currency = ip2.get() if (value.get() == ""): tkinter.messagebox.showerror( "Error", "Amount Not Entered.\n Please a valid amount.") elif (from_currency == "Select" or to_currency == "Select"): tkinter.messagebox.showerror( "Error", "Currency Not Selected.\n Please select the currencies to be converted" ) else: new_amt = c.convert(from_currency, to_currency, float(value.get())) new_amount = float("{:.4f}".format(new_amt)) output.insert(0, str(new_amount))
def pip(request): c = CurrencyRates() s = CurrencyCodes() decimal = 0.0001 currency_list = { 'GBP', 'AUD', 'CAD', 'CHF', 'CNY', 'SEK', 'NZD', 'MXN', 'SGD', 'HKD', 'INR', 'USD', 'EUR', 'JPY' } if request.method == "POST": pip = 0 base_currency = request.POST['sel2_1'] counter_currency = request.POST['sel2_2'] account_currency = request.POST['sel2_3'] trade_size2_4 = request.POST['trade_size2_4'] if trade_size2_4 is '': trade_size2_4 = 10000 else: trade_size2_4 = float(trade_size2_4) if counter_currency == account_currency: mp = 1.0 else: mp = c.get_rate(account_currency, counter_currency) if (base_currency == 'JPY') or (counter_currency == 'JPY'): decimal = 0.01 symbol = s.get_symbol(counter_currency) pip = (decimal * trade_size2_4) / mp return render( request, 'pip.html', { 'symbol': symbol, 'currencyList': currency_list, 'pip': pip, 'base_currency': base_currency, 'counter_currency': counter_currency, 'account_currency': account_currency, 'mp': mp }) return render(request, 'pip.html', {'currencyList': currency_list})
def get_currency_rates(currency): """ The flask API for getting the rate of the currency. :param currency: :return: """ cur_rates_obj = CurrencyRates() target_cur = request.args.get('target') finding_date = request.args.get('date') if currency and target_cur and finding_date: date_obj = datetime.datetime.strptime(finding_date, '%d-%m-%Y,%H:%M:%S') rate_value = cur_rates_obj.get_rate(currency, target_cur, date_obj) elif currency and target_cur and not finding_date: rate_value = cur_rates_obj.get_rate(currency, target_cur) elif currency and not target_cur and finding_date: date_obj = datetime.datetime.strptime(finding_date, '%d-%m-%Y,%H:%M:%S') rate_value = cur_rates_obj.get_rates(currency, date_obj) else: rate_value = cur_rates_obj.get_rates(currency) return jsonify({ 'source_currency': currency, 'exchange_value': rate_value, 'status_code': 200 })
def post(self): postedData = request.get_json() # Verify validity of posted data status_code = DataCheck(postedData, "usdtogbp") if (status_code != 200): retJson = { "Message": "An error happened", "Status Code": status_code } return jsonify(retJson) # If i am here, then status_code == 200 username = postedData["username"] password = postedData["password"] x = postedData["x"] x = int(x) # verifyCredentials retJson, error = verifyCredentials(username, password) if error: return jsonify(retJson) # Finding tokens tokens = users.find({"username": username})[0]["tokens"] # Verify token existance if tokens <= 0: return jsonify(generateReturnDictionary(303, "Not Enough Tokens")) # Convert the posted data since tokens exist using CurrencyRates module c = CurrencyRates() rb = c.convert('USD', 'GBP', x) # Conversion is ready, next step ----> Tokens = Tokens-1 users.update_one({"username": username}, {"$set": { "tokens": tokens - 1 }}) return jsonify(generateReturnDictionary(200, rb))
def __init__(self, bot): self.bot = bot self.exchangeNames = { "EUR": ["eur", "euro member countries"], "IDR": ["idr", "indonesia rupiah"], "BGN": ["bgn", "bulgaria lev"], "ILS": ["ils", "israel shekel"], "GBP": ["gbp", "united kingdom pound"], "DKK": ["dkk", "denmark krone"], "CAD": ["cad", "canada dollar"], "JPY": ["jpy", "japan yen"], "HUF": ["huf", "hungary forint"], "RON": ["ron", "Romania New Leu"], "MYR": ["myr", "malaysia ringgit"], "SEK": ["sek", "sweden krona"], "SGD": ["sgd", "singapore dollar"], "HKD": ["hkd", "hong kong dollar"], "AUD": ["aud", "australia dollar"], "CHF": ["chf", "switzerland franc"], "KRW": ["krw", "korea won", "korea south won"], "CNY": ["cny", "china yun renminbi"], "TRY": ["try", "turkey lira"], "HRK": ["hrk", "croatia kuna"], "NZD": ["nzd", "new zealand dollar"], "THB": ["thb", "thailand baht"], "USD": ["usd", "united states dollar"], "NOK": ["nok", "norway krone"], "RUB": ["rub", "russia ruble"], "INR": ["inr", "india ruppe"], "MXN": ["mxn", "mexico peso"], "CZK": ["czh", "czech republic koruna"], "BRL": ["brl", "brazil real"], "PLN": ["pln", "poland zloty"], "PHP": ["php", "philippines peso"], "ZAR": ["zar", "south africa rand"] } self.CurrencyRates = CurrencyRates() self.CurrencyCodes = CurrencyCodes()
def save(self, *args, **kwargs): c = CurrencyRates() if not self.id: entry_risk = ((self.entry_price - self.stop_price)*self.position/self.instrument.tickunit)\ *self.instrument.tickprice*self.num_cons self.entry_risk = self.current_risk = c.convert( self.instrument.currency, 'USD', entry_risk) if self.exits.count() > 0: self.num_close_cons = self.exits.aggregate( Sum('num_cons'))['num_cons__sum'] self.num_open_cons = self.num_cons - self.num_close_cons current_risk = ((self.current_price - self.stop_price)*self.position/self.instrument.tickunit)\ *self.instrument.tickprice*self.num_open_cons self.current_risk = c.convert(self.instrument.currency, 'USD', current_risk) current_profit = ((self.current_price - self.entry_price)*self.position/self.instrument.tickunit)\ *self.instrument.tickprice*self.num_open_cons self.current_profit = c.convert(self.instrument.currency, 'USD', current_profit) self.is_open = True if self.num_open_cons > 0 else False super(FuturesEntry, self).save(*args, **kwargs)
def RealTimeCurrencyConversion(): from forex_python.converter import CurrencyRates c = CurrencyRates() from_currency = variable1.get() to_currency = variable2.get() if (Amount1_field.get() == ""): tkinter.messagebox.showinfo( "Error !!", "Amount Not Entered.\n Please a valid amount.") elif (from_currency == "currency" or to_currency == "currency"): tkinter.messagebox.showinfo( "Error !!", "Currency Not Selected.\n Please select FROM and TO Currency form menu." ) else: new_amt = c.convert(from_currency, to_currency, float(Amount1_field.get())) new_amount = float("{:.4f}".format(new_amt)) Amount2_field.insert(0, str(new_amount))
def show_amount(): """Show conversion result.""" from_conv = request.args["convert_from"] to = request.args["convert_to"] try: amount = Decimal(request.args["amount"]) except DecimalException: session['error'] = "Amount Is Not Valid" return redirect("/error") """ Request arguments """ c = CurrencyRates() try: text = c.convert(from_conv, to, amount) except RatesNotAvailableError: session['error'] = "Invalid Currency Code" return redirect("/error") """ Convert currency """ return render_template("conversion.html", text=text) """ Append conversion.html to browser. """
def convert(e): c = CurrencyRates() from_currency = variable1.get() to_currency = variable2.get() try: if from_amount_entry.get() == '': tk.messagebox.showerror('Error', 'Please enter a valid amount.') elif from_currency == '' or to_currency == '': tk.messagebox.showerror('Error', 'Please select a currency pair.') else: new_amt = c.convert(from_currency, to_currency, float(from_amount_entry.get())) new_amount = float(f'{new_amt:.2e}') to_amount_label.config(text=f'{new_amount:,}') except ValueError: tk.messagebox.showerror('Error', 'Please enter a valid amount.')
def convert(): try: amount = request.form["amount"] to = request.form["to"] from_code = request.form["from-code"] c = CurrencyRates() converted = c.convert(from_code, to, float(amount)) def get_name_symbol(code): return next((item for item in currency_data if item["cc"] == code), None) from_name = get_name_symbol(from_code)['name'] to_symb = get_name_symbol(to)['symbol'] to_name = get_name_symbol(to)['name'] flash( f"{amount} {from_name} equals {to_symb}{round(converted, 2)} {to_name}", 'success') except forex_python.converter.RatesNotAvailableError: flash(f"{from_code} to {to} conversion is currently not available.", 'error') return redirect('/convert')
class TestForceDecimalAmountConvert(TestCase): """ Test the force_decimal=True type enforcing """ def setUp(self): self.c = CurrencyRates(force_decimal=True) def test_amount_decimal_convert(self): amount = self.c.convert('USD', 'INR', Decimal('10.45')) self.assertTrue(isinstance(amount, Decimal)) def test_amount_decimal_convert_date(self): date_obj = datetime.datetime.strptime('2010-05-10', "%Y-%m-%d").date() amount = self.c.convert('USD', 'INR', Decimal('10.45'), date_obj) self.assertTrue(isinstance(amount, Decimal)) def test_amount_decimal_invalid_type(self): self.assertRaises(DecimalFloatMismatchError, self.c.convert, 'USD', 'INR', 10.45) def test_decimal_get_rates_valid_code(self): all_rates = self.c.get_rates('USD') # Check if return value of get_rates dictionary self.assertTrue(isinstance(all_rates, dict)) # Test at least one rate value returned self.assertTrue(len(all_rates.keys())) # Test one rate in returned dict is now a Decimal self.assertTrue(isinstance(all_rates.get('INR'), Decimal)) def test_decimal_get_rates_with_date(self): date_obj = datetime.datetime.strptime('2010-05-10', "%Y-%m-%d").date() all_rates = self.c.get_rates('USD', date_obj) # Check if return value of get_rates dictionary self.assertTrue(isinstance(all_rates, dict)) # Test at least one rate value returned self.assertTrue(len(all_rates.keys())) # Test one rate in returned dict is now a Decimal self.assertTrue(isinstance(all_rates.get('INR'), Decimal)) def test_decimal_get_rates_invalid_code(self): self.assertRaises(RatesNotAvailableError, self.c.get_rates, 'XYZ') def test_decimal_get_rate_with_valid_codes(self): rate = self.c.get_rate('USD', 'INR') # check if return value is Decimal self.assertTrue(isinstance(rate, Decimal)) def test_decimal_get_rate_with_date(self): date_obj = datetime.datetime.strptime('2010-05-10', "%Y-%m-%d").date() rate = self.c.get_rate('USD', 'INR', date_obj) # check if return value is Decimal self.assertTrue(isinstance(rate, Decimal)) def test_decimal_get_rate_with_invalid_codes(self): # raise exception for invalid currency codes self.assertRaises(RatesNotAvailableError, self.c.get_rate, 'ABCD', 'XYZ')
def get_money_interval(): user_difficulty = input("please put difficulty number:") user_difficulty_int = int(user_difficulty) c = CurrencyRates() currenecy = c.get_rate('USD', 'ILS') print(currenecy) print( "The machine will genrreate randon nmber, you will have to guess the value to ILS " ) Random_number = int(random.randint(1, 101)) print(Random_number) total_amount = Random_number * currenecy user_guess1 = int( input("user please a number what will be the Cuerrency ")) user_guess2 = int(user_guess1 * currenecy) var1 = -1 interval = int(user_difficulty_int - user_guess2) interval2 = int(user_difficulty_int + user_guess2) machine_sum = currenecy * Random_number user_guess = int(user_guess2 + interval + interval2) user_sum = int(currenecy * user_guess) try: if user_sum == machine_sum: print("yes you are correct") elif user_sum != machine_sum: print("NOPE - wrong guess Please play again") except: print("Worng calc") # exit() for x in range(2): return get_money_interval() break
def quote(query, convert): # Contata API e ajusta os valores de moeda try: c = CurrencyRates() # Valores de moeda (Forex-Python) stock = str(query[0]) amnt = int(query[1]) tickr = Ticker(stock) # Informaçoes da ação (yahooquery) data = tickr.summary_detail prc = data[stock]['regularMarketPreviousClose'] currency = data[stock]['currency'] if convert: # Conversão de moeda prc = round(c.convert(currency, 'BRL', prc), 2) val = prc * amnt return [stock, prc, amnt, val, 'BRL'] val = prc * amnt # Sem conversão return [stock, prc, amnt, val, currency] except: return ['SÍMBOLO INVÁLIDO', 0, 0, 0] # Em caso de erro interno
class TestGetRate(TestCase): """ Test get_rate function using valid and invalid currency codes """ def setUp(self): self.c = CurrencyRates() def test_get_rate_with_valid_codes(self): rate = self.c.get_rate('USD', 'INR') # check if return value is float self.assertTrue(isinstance(rate, float)) def test_get_rate_with_date(self): date_obj = datetime.datetime.strptime('2010-05-10', "%Y-%m-%d").date() rate = self.c.get_rate('USD', 'INR', date_obj) # check if return value is float self.assertTrue(isinstance(rate, float)) def test_get_rate_with_invalid_codes(self): # raise exception for invalid currency codes self.assertRaises(RatesNotAvailableError, self.c.get_rate, 'ABCD', 'XYZ')
def convert(): """Show index.html.""" c = CurrencyRates() amount = request.form.get('amount') rate_from = request.form.get('rate-from') rate_too = request.form.get('rate-too') cc = CurrencyCodes() name_from = cc.get_currency_name(rate_from) name_to = cc.get_currency_name(rate_too) symbol = cc.get_symbol(rate_too) if not amount: con_rate = "{0:.2f}".format(round(c.get_rate(rate_from, rate_too), 2)) return render_template("convert.html", con_rate=con_rate, name_from=name_from, name_to=name_to, symbol=symbol, rates=session.get("rates"), bit=session.get("bit")) else: con_rate = "{0:.2f}".format( round(c.convert(rate_from, rate_too, amount), 2)) return render_template("convert.html", con_rate=con_rate, name_from=name_from, name_to=name_to, symbol=symbol, rates=session.get("rates"), bit=session.get("bit"))
def _fetch_all_rates(self, provider: converter.CurrencyRates, base_currency: str, date_obj: date) -> []: try: _rates = provider.get_rates(base_cur=base_currency, date_obj=date_obj) return [ self.serializer(base_currency=base_currency, currency=key, date=date_obj, value=value) for key, value in _rates.items() ] except converter.RatesNotAvailableError as e: logging.error(e) raise RatesNotAvailableError
def convert_to_all(input_currency, amount, currencies): """ convert amount of input_currency to all supported currencies :param input_currency: input currency code :param amount: amount of input currency :param currencies: list of supported currencies codes :return: dictionary, key - currency code, value - converted amount of input_currency { <3 letter output currency code>: <float> ... } """ output_dict = {} c = CurrencyRates() for curr in currencies: if curr == input_currency: continue try: rate = c.get_rate(input_currency, curr) except RatesNotAvailableError: continue output_dict[curr] = round(amount * rate, 2) return output_dict
def currencies(): coins = ["bitcoin", "ethereum", "bitcoin-cash"] n = 0 coin_usd = [] coin_try = [] for coin in coins[:]: url = "https://api.coinmarketcap.com/v1/ticker/"+coin+"/" #print("Fetching prices for " + coin + "...") resp = requests.get(url, verify=True) #verify is checking SSL certificate #if(resp.status_code != 200): #print("Status: ", resp.status_code,) data = json.loads(resp.text)[0] cr = CurrencyRates() usd = float(data['price_usd']) tl = cr.convert("USD","TRY",usd) coin_usd.append(usd) coin_try.append(tl) n += 1 usdtry = cr.get_rate('USD','TRY') chftry = cr.get_rate('CHF','TRY') eurtry = cr.get_rate('EUR','TRY') result = "BTC: " + str(coin_usd[0]) + " USD" + "\n" + "ETH: " + str(coin_usd[1]) + " USD" + "\n" + "BCH: " + str(coin_usd[2]) + " USD" + "\n" + "USD/TRY: " + str(usdtry) + "\n" + "CHF/TRY: " + str(chftry) + "\n" + "EUR/TRY: " + str(eurtry) + "\n" return result
class TestAmountConvert(TestCase): """ test amount conversion from one currency to other """ def setUp(self): self.c = CurrencyRates() def test_amount_convert_valid_currency(self): amount = self.c.convert('USD', 'INR', 10) # test if amount returned in float self.assertTrue(isinstance(amount, float)) def test_amount_convert_date(self): date_obj = datetime.datetime.strptime('2010-05-10', "%Y-%m-%d").date() amount = self.c.convert('USD', 'INR', 10, date_obj) # test if amount returned in float self.assertTrue(isinstance(amount, float)) def test_amount_convert_invalid_currency(self): # test if amount returned in float self.assertRaises(RatesNotAvailableError, self.c.convert, 'ABC', 'XYZ', 10)
def get_options(cls): browser = cls._create_browser() browser.open(cls.OPTIONS_URL) soup = browser.get_current_page() p = soup.select("p.hero-description") string = p[1].get_text() # Calculate the price in USD eur = float(string[string.index("€") + 1:string.index("/")]) price = round(CurrencyRates().convert("EUR", "USD", eur), 2) name, _ = cls.get_metadata() option = VpnOption(name, "OpenVPN", price, sys.maxsize, sys.maxsize) return [option]
def _parse_kvm_option(plan, name): elements = plan.findAll("div", {'class': 'info'}) eur = float(plan.find('div', {'class': 'plans-price'}).span.text.replace('\u20AC', '')) option = VpsOption( name=name, storage=elements[0].text.split(' GB')[0], cores=elements[1].text.split(' vCore')[0], memory=elements[3].text.split(' GB')[0], bandwidth='unmetered', connection=int(elements[4].text.split(' GB')[0]) * 1000, price=round(CurrencyRates().convert("EUR", "USD", eur), 2), purchase_url=plan.a['href'], ) return option
def db_price_func(stock_ticker): """ This function provides most recent price of the given stock. Args: stock_ticker: Stock Ticker Returns: Latest price of the given stock (in $). """ stock_price = float(si.get_live_price(stock_ticker)) if ".NS" in stock_ticker or ".BO" in stock_ticker: stock_price = stock_price / CurrencyRates().get_rate("USD", "INR") return stock_price
def convert_curr(): """Function that converts amount from one currency to another Args: None Return: None: only prints out the results """ # create the currency instance curr_instance = CurrencyRates() # take user inputs amount = int(input("Enter the amount: ")) from_currency = input("From Currency: ").upper() to_currency = input("To Currency: ").upper() print(from_currency, " To ", to_currency, amount) # perform the conversion result = curr_instance.convert(from_currency, to_currency, amount) print(result)
def convert_currency(): """ The flask API for changing the currency rate from source currency to target currency. :return: """ source = request.args.get('source') target = request.args.get('target') amount = request.args.get('amount') finding_date = request.args.get('date') cur_rates_obj = CurrencyRates(force_decimal=True) if not source or not target or not amount: return jsonify({ 'error': { 'message': 'data not passed: source or target or amount.' }, 'status_code': 400 }) elif finding_date: date_obj = datetime.datetime.strptime(finding_date, '%d-%m-%Y,%H:%M:%S') value = cur_rates_obj.convert(source, target, Decimal(amount), date_obj) else: value = cur_rates_obj.convert(source, target, Decimal(amount)) return jsonify({ 'source_currency': source, 'target_currency': target, 'amount': amount, 'converted_value': value, 'status_code': 200 })
class Currency(): 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 check_valid_code(self, frm, to, amount): results = self.results if frm in self.curr_codes: results['frm'] = 'ok' else: results['frm'] = 'no' if to in self.curr_codes: results['to'] = 'ok' else: results['to'] = 'no' if amount == '': results['amount'] = 'no' else: results['amount'] = 'ok' return self.handle_results(results, frm, to, amount) def handle_results(self, results, frm, to, amount): if 'no' in results.values(): return self.give_error(results, frm, to) else: return self.conversion(frm, to, amount) def give_error(self, results, frm, to): if results['frm'] == 'no': flash(f'Not a valid code: {frm}') if results['to'] == 'no': flash(f'Not a valid code: {to}') if results['amount'] == 'no': flash('Not a valid amount.') return 'error' def conversion(self, frm, to, amount): x = self.codes.get_symbol(to) conv = self.cr.convert(frm, to, float(amount)) conv = round(conv, 2) conv = (f'{x}{conv}') return conv
class currencyfilter(absfilter): def __init__(self): self.__currency = CurrencyRates() def msgprocess(self, msg): text = '' allmatched = re.findall(u'(\d+日元)', msg) if len(allmatched) > 0: for matched in allmatched: jpy = matched[:-2] cny = self.__currency.convert('JPY', 'CNY', int(jpy)) text += matched + ' => ' + str(cny) + u'人民币' + '\n' return text else: return None
def convert(): """ Display converted amount""" if request.method == 'POST': # storing three form inputs into variables first_currency = request.form.get("convert-from") second_currency = request.form.get("convert-to") amt = request.form.get("amount") # write 3 validation in the form of if statements if (first_currency in legit_currencies and second_currency in legit_currencies and amt.isalpha() is False): # if first_currency in legit_currencies # if they all pass, this is the HAPPY path currency_rate = CurrencyRates(force_decimal=True) converted_amount = round( currency_rate.convert(first_currency, second_currency, Decimal(amt)), 2) return render_template('converter.html', converted_amt=converted_amount) else: return render_template('base.html', first_currency=first_currency, second_currency=second_currency, error=True)
def calculateNets(df, Currency, session_id=session_id): from forex_python.converter import CurrencyRates c = CurrencyRates().get_rate('USD', Currency) df['upfrontCommissionAmount'] = df['upfrontCommission'] / 100 * df[ 'baseFare'] df['backendCommissionAmount'] = df['backendCommission'] / 100 * df[ 'baseFare'] df['segmentEarningsAmount'] = (df['segmentEarnings'] * c) * df['numberOfSegments'] df['netPrice'] = round( df['totalPrice'] - (df['upfrontCommissionAmount'] + df['backendCommissionAmount'] + df['segmentEarningsAmount']), 2) return df
def extract_historical_currency_rates(Start_date, Current_date): date_value_df = pd.date_range(start=Start_date, end=Current_date) #print(date_value_df) currency_df = pd.DataFrame(columns=('Date', 'USD_to_INR_Rate', 'GBP_to_INR_Rate')) #,'INR_symbol')) USD_to_INR_Rate = [] GBP_to_INR_Rate = [] #print(currency_df) for i in range(len(date_value_df)): c = CurrencyRates() #print(date_value_df[i]) USD_to_INR_Rate = round( c.get_rates('USD', date_value_df[i]).get('INR'), 2) GBP_to_INR_Rate = round( c.get_rates('GBP', date_value_df[i]).get('INR'), 2) dict_rates = { 'Date': date_value_df[i], 'USD_to_INR_Rate': USD_to_INR_Rate, 'GBP_to_INR_Rate': GBP_to_INR_Rate } currency_df = currency_df.append(dict_rates, ignore_index=True) #print("USD_to_INR_Rate = ",USD_to_INR_Rate) #print("GBP_to_INR_Rate = ", GBP_to_INR_Rate) c = CurrencyCodes() #currency_df['INR_symbol'] = c.get_symbol('INR') currency_df['Date'] = currency_df['Date'].dt.strftime('%m/%d/%Y') currency_df['Date'] = pd.to_datetime(currency_df.Date, format='%m/%d/%Y') #print("symbol = ",currency_df['INR_symbol']) currency_df.index = currency_df['Date'] # currency_df.drop(['Date'], axis=1,inplace=True) # activate this line to do Graph plotting print(currency_df) return currency_df
def setUp(self): self.c = CurrencyRates()
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)
def setUp(self): self.c = CurrencyRates(force_decimal=True)
def forex(from_currency, to_currency, amount): try: currency_rates = CurrencyRates() return currency_rates.convert(from_currency, to_currency, amount) except: return amount