Пример #1
0
def returnConversion(location):
    c = CurrencyRates()
    with open('common_currencies.json') as currency_file:
        currencies = json.load(currency_file)
    for code, info in currencies.iteritems():
        if info['capital'] == location:
            if code == 'EUR': return 1.
            conversion = c.get_rate(code, 'EUR')
            break
        else:
            conversion = 1.

    return conversion
Пример #2
0
    def __init__(self):

        self.df_path = 'Pickles/classifiedDF.pickle'
        self.df = pd.read_pickle(self.df_path)
        self.c = CurrencyRates()

        self.funding_overview = None
        self.funding_overview_df = None

        self.uni_funding_dict = None

        self.GBP_groups = ['EPSRC', 'Industrial']
        self.EUR_groups = ['5GPPP', 'FIRE', 'Other EU']
Пример #3
0
 def do_update(self):
     from forex_python.converter import CurrencyRates
     cr = CurrencyRates()
     log.info("fetching currency update %s to %s" %
              (self.conv_from, self.conv_to))
     try:
         conv = cr.get_rate(self.conv_from, self.conv_to)
         self.text = "1 %s = %s%.2f %s" % (
             self.conv_from, self.get_color_compare(
                 conv, self.last_conv), conv, self.conv_to)
         self.last_conv = conv
     except requests.exceptions.RequestException as e:
         logging.warning("couldn't get update: %s" % e)
    def create_europe_gfinity_friday(self, contents):
        contents = self.create_tournament(contents)
        currency_converter = CurrencyRates()
        gbp_exchange_rate = currency_converter.get_rate('GBP', 'USD')

        contents = contents.replace("VOGANBOT_PRIZE_1",
                                    str(200 * gbp_exchange_rate))
        contents = contents.replace("VOGANBOT_PRIZE_2",
                                    str(50 * gbp_exchange_rate))
        contents = contents.replace("VOGANBOT_TOTAL_PRIZE",
                                    str(250 * gbp_exchange_rate))

        return contents
def get_conversion():
    try:
        c = CurrencyRates()
        current_rate = c.get_rate('USD', 'CAD')
    except:
        # Where USD is the base currency you want to use
        url = 'https://api.exchangerate-api.com/v4/latest/USD'

        # Making our request
        response = requests.get(url)
        data = response.json()
        current_rate = data['rates']['CAD']
    return float(current_rate)
def convert(amount, input_currency, output_currency):
    input_currency_code = get_currency_code(input_currency)
    if input_currency_code is None:  # Input currency code was not found - unknown currency
        raise UnknownCurrencyError

    if output_currency is not None:
        output_currency_code = get_currency_code(output_currency)
        if output_currency_code is None:  # Output currency code was not found - unknown currency
            raise UnknownCurrencyError
        currency_data = [{'cc': output_currency_code}]
    else:
        # Getting currency data from file
        currency_data = get_currency_data()

    c = CurrencyRates()
    b = BtcConverter()
    output_currencies = dict(
    )  # Dictionary to store converted amounts for each currency

    # Converting currency
    for item in currency_data:
        if item['cc'] == input_currency_code:  # Out currency == in currency
            if output_currency is None:
                continue
            else:
                raise SameCurrencyError

        try:
            if input_currency_code == "BTC":  # Bitcoin is input currency
                output_currencies[item['cc']] = round(
                    b.convert_btc_to_cur(amount, item['cc']), 2)

            elif item['cc'] == "BTC":  # Bitcoin is output currency
                output_currencies[item['cc']] = round(
                    b.convert_to_btc(amount, input_currency_code), 5)

            else:  # Other currencies than bitcoin
                output_currencies[item['cc']] = round(
                    c.convert(input_currency_code, item['cc'], amount), 2)

        except RatesNotAvailableError:
            if output_currency is None:  # Output currency not entered, currencies without available rates are skipped
                pass
            else:  # Output currency entered => not available currency rate yields error
                raise RatesNotAvailableError

    output_data = dict()
    output_data['input'] = {'amount': amount, 'currency': input_currency_code}
    output_data['output'] = output_currencies

    return json.dumps(output_data, indent='\t')
Пример #7
0
    def load_wallstreet(self):
        with pymongo.MongoClient('localhost', 27017) as client:
            db = client['drug_database']
            table = db['wallstreet']

            docs = list(table.find())

        docs = add_scraping_session(docs)

        docs = {(doc['vendor'], doc['title'], doc['scraping_session'], doc['price']): doc for doc in docs}.values() #remove duplicates
        counts = sorted(Counter(d['scraping_session'] for d in docs).items())

        bad_dates = [date for date, count in counts if count < 3200]
        docs = [d for d in docs if d['scraping_session'] not in bad_dates]

        c = CurrencyRates()
        find_unit = re.compile(r'(\d+\.?\d*)\s*({})'.format('|'.join(self.units)), re.IGNORECASE)
        find_multi = re.compile(r'(\d+)\s*x', re.IGNORECASE)
        for doc in docs:
            del doc['_id']
            doc['market'] = 'wallstreet'

            doc['ships_from'] = ' '.join(s.replace('Ships from:', '').strip() for s in doc['ships_from'].split('\n')).strip()
            stripped = ' '.join(s.replace('Only ships to certain countries', '').strip() for s in doc['ships_to'].split('\n')).strip()
            doc['ships_to'] = [s.replace('Ships Worldwide', 'WW').replace('WW WW', 'WW').strip() for s in stripped.split(',')]

            match = find_unit.search(doc['title'])
            doc['price_unit'] = doc['price_unit'].lower().strip().replace('/', '')
            if doc['price_unit'] == 'piece':
                doc['price_unit'] = match.group(2).lower() if match else None

            multi = find_multi.search(doc['title'])
            doc['amount'] = float(match.group(1)) if match and float(match.group(1)) != 0 else 1
            if multi and int(multi.group(1)) != 0:
                doc['amount'] *= int(multi.group(1))

            is_dollar = '$' in doc['price']
            if doc['price_unit'] not in self.gram_factors:
                self.bad_docs.append(doc)
            else:
                doc['price'] = to_float(doc['price'].strip('$').strip('€')) / doc['amount'] / self.gram_factors[doc['price_unit']]
                doc['date_mid'] = dt.datetime.combine(doc['scraping_session'].date(), dt.datetime.min.time()) # transfer dates to midnight

                if is_dollar:
                    date = doc['date_mid']
                    if not date in self.rates:
                        self.rates[date] = c.get_rate('USD', 'EUR', date)
                    doc['price'] *= self.rates[date]

                self.docs.append(doc)
Пример #8
0
def get_currency(list_codes, sleeping=0):
    print('Lazy-search for real time rates')
    c = CurrencyRates()
    rate_matrix = np.zeros((len(list_codes), len(list_codes)))

    for n, currency in enumerate(list_codes):
        print(f'Rate {n+1} out of {len(list_codes)}')
        for m, other_currency in enumerate(list_codes):
            rate = c.get_rate(currency, other_currency)
            time.sleep(sleeping)
            rate_matrix[m][n] = rate

    df_rates = pd.DataFrame(rate_matrix, index=list_codes, columns=list_codes)
    return df_rates
Пример #9
0
    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]
Пример #10
0
def RealTimeCurrencyConversion():
    from forex_python.converter import CurrencyRates
    c = CurrencyRates()

    from_currency = variable1.get()
    to_currency = variable2.get()

    new_amount = c.convert(from_currency, to_currency,
                           float(Amount1_field.get()))
    # insert method inserting the
    # value in the text entry box.
    new_value = str(new_amount)

    Amount2_field.insert(0, new_value)
    def load_currency(self, input_amount, input_curr, output_curr):
        self.input['amount'] = input_amount
        self.input['currency'] = input_curr
        self.output = dict()
        currency_rates = CurrencyRates()

        if output_curr == 'ALL' or output_curr == 'None':
            self.output = dict(currency_rates.get_rates(input_curr))
            self.output.update(
                (result_key, result_value * input_amount)
                for result_key, result_value in self.output.items())
        else:
            self.output[output_curr] = currency_rates.get_rate(
                input_curr, output_curr) * input_amount
Пример #12
0
def play_me(difficult):
    c = CurrencyRates()
    convert = c.get_rate('USD', 'ILS')
    d = int(difficult)
    interval = get_money_interval()
    aaa = get_guess_from_user_currency(interval)
    conversion = float(convert) * int(interval)
    low_interval = (int(conversion) - (5 - d))
    high_interval = (int(conversion) + (5 - d))
    if high_interval >= int(aaa) and int(aaa) >= low_interval:
        print(True)
        score_calc(difficult)
    else:
        print(False)
Пример #13
0
def currency_Exchange(country, visa_list) -> list:
    """
    Pulls the currency data
    """
    final_list = []
    c = CurrencyRates()
    for visa in visa_list:
        symbol = get_currency(visa)
        try:
            rate = c.get_rate(country, symbol)
        except Exception:
            rate = "??"
        final_list.append([visa, str(rate)])
    return final_list
Пример #14
0
 def __init__(self, loc='20211220.csv'):
     dt = loc.split('.')[-2]
     dt = dt if '/' not in dt else dt.split('/')[-1]
     self.yr, self.mth, self.day = int(dt[:4]), int(dt[4:6]), int(dt[6:])
     self.c = CurrencyRates()
     self.cryptos = ['BTC', 'ETH']
     df = pd.read_csv(loc)
     arr = []
     for _, row in df.iterrows():
         arr.append([
             row['bank'],
             self._2usd(row['amount'], row['currency']), row['currency']
         ])
     self.df = pd.DataFrame(arr, columns=['bank', 'usd', 'orig'])
Пример #15
0
 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
Пример #16
0
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
Пример #17
0
def combine_data(current_holdings_df, api_data_return):
    """
    Function to combine the data for the book values in the original Excel workbook (holdings.xlsx) and
    the data from the IEX Cloud API, Yahoo Finance API and Forex API.

    Parameters
    ----------
    current_holdings_df : dict
        dictionary of the Excel sheets (keys) and the associated data rows appearing on that sheet (values). The values
        are key:value pairs, with the key being the column header and the value being the corresponding data for that
        row.
    api_return_data : dict
        dictionary of the Excel sheets (keys) and the associated data rows appearing on that sheet (values). The values
        are key:value pairs, with the key being the column header and the value being the corresponding data for that
        row.

    Returns
    -------
    combined_holdings_dict : dict
        dictionary of the combined data.
    """

    combined_holdings_dict = api_data_return

    for keys, values in current_holdings_df.items():

        for key_part, value_part in values.items():
            temp = []
            if key_part == 'purchase_date' or key_part == 'book_price' or key_part == 'purchase_currency' or key_part == 'qty':

                for i in value_part.values():
                    temp.append(i)

                combined_holdings_dict[keys][key_part] = temp

                if key_part == 'purchase_date':
                    temp_FX = []

                    for i in value_part.values():
                        date_obj = i.to_pydatetime()
                        USD_CAD_purchase = CurrencyRates()
                        USD_CAD_purchase = USD_CAD_purchase.get_rate(
                            'USD', 'CAD', date_obj)
                        temp_FX.append(USD_CAD_purchase)

                    combined_holdings_dict[keys][
                        'fx_USDCAD_purchase'] = temp_FX

    return combined_holdings_dict
Пример #18
0
def index():
    c = CurrencyRates()
    btc_converter = BtcConverter()
    price_json = c.get_rates('INR')
    result = [None, None, None]
    if (request.method == 'POST'):
        stock_name = request.form['stock_name']
        if (stock_name != ""):
            result = callback(stock_name)
        else:
            result = [None, None, None, None]
    prices = []
    for key, value in price_json.items():
        prices.append((key, value, btc_converter.get_latest_price(key)))
    print('No of Supported Currencies: ', len(price_json), '||||File Type: ',
          type(price_json))
    legend = 'BitCoin Price Index'
    temperatures = [
        73.7, 73.4, 73.8, 72.8, 68.7, 65.2, 61.8, 58.7, 58.2, 58.3, 60.5, 65.7,
        70.2, 71.4, 71.2, 70.9, 71.3, 71.1
    ]
    times = [
        time(hour=11, minute=14, second=15),
        time(hour=11, minute=14, second=30),
        time(hour=11, minute=14, second=45),
        time(hour=11, minute=15, second=00),
        time(hour=11, minute=15, second=15),
        time(hour=11, minute=15, second=30),
        time(hour=11, minute=15, second=45),
        time(hour=11, minute=16, second=00),
        time(hour=11, minute=16, second=15),
        time(hour=11, minute=16, second=30),
        time(hour=11, minute=16, second=45),
        time(hour=11, minute=17, second=00),
        time(hour=11, minute=17, second=15),
        time(hour=11, minute=17, second=30),
        time(hour=11, minute=17, second=45),
        time(hour=11, minute=18, second=00),
        time(hour=11, minute=18, second=15),
        time(hour=11, minute=18, second=30)
    ]
    links = ['a', 'b', 'c']
    return render_template('index.html',
                           values=temperatures,
                           labels=times,
                           legend=legend,
                           links=links,
                           current_prices=prices,
                           result=result)
Пример #19
0
 def findRate(self):
     c = CurrencyRates()
     print('hi')
     currency = str(self.comboBox.currentText())
     currency2 = str(self.comboBox_2.currentText())
     currentDay = datetime.now().day
     currentMonth = datetime.now().month
     currentYear = datetime.now().year
     print('hello')
     new2 = float(self.plainTextEdit.toPlainText())
     print(new2)
     timing = datetime(2016, 1, 1, 18, 36, 28, 151012)
     print(timing)
     exchange = c.convert(currency, currency2, new2, timing)
     self.textEdit.setText(str(exchange))
def currency_nxgraph(list_codes, sleeping=0, adjmatrix=False):
    print('Lazy-search for real time rates')
    c = CurrencyRates()
    d = {}
    for currency in list_codes:
        print(f'Checking for {currency}')
        d[currency] = {}
        remaining_codes = [i for i in list_codes if i not in list(d.keys())]
        for other_currency in remaining_codes:
            log_rate = np.log(c.get_rate(currency, other_currency))
            d[currency][other_currency] = {}
            d[currency][other_currency]['weights'] = log_rate
        time.sleep(0.5)
    G = nx.from_dict_of_dicts(d)
    return G
Пример #21
0
async def conversor(ctx, moeda1, moeda2, quantidade=None):
    """Vê o valor da moeda 1 em moeda 2"""
    try:
        channel = ctx.channel
        await channel.trigger_typing()
        c = CurrencyRates()
        msg = c.get_rate(f'''{moeda1.upper()}''', f'''{moeda2.upper()}''')
        if quantidade is None:
            await ctx.send('Esse é o valor da cotacao atual do ``{}`` em ``{}``: **{}**'.format(moeda1.upper(), moeda2.upper(), msg))
        else:
            msg = msg * quantidade
            await ctx.send('Esse é o valor de {} ``{}`` em ``{}``: **{}**'.format(quantidade, moeda1.upper(), moeda2.upper(), msg))
    except:
        msg = await ctx.send('Tente utilizar o codigo de uma moeda existente. **Por exemplo: $conversor usd brl**')
        await msg.add_reaction('❤')
Пример #22
0
 def findVolatility(self):
     currency1 = str(self.comboBox_7.currentText())
     currency2 = str(self.comboBox_8.currentText())
     startYear = str(self.comboBox_9.currentText())
     endYear = str(self.comboBox_10.currentText())
     c = CurrencyRates()
     listX = []
     for x in range(int(startYear), int(endYear) + 1):
         for y in range(1, 13):
             timing = datetime(x, y, 1, 18, 36, 28, 151012)
             exchange = c.convert(currency1, currency2, 1, timing)
             listX.append(exchange)
     print(listX)
     v = statistics.stdev(listX)
     self.textEdit_3.setText(str(v))
Пример #23
0
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
Пример #24
0
def index(request):
    """
    This is the view which represents the dashboard page.
    It indexes every other app on the platform

    :param request: Django request
    :return: redirect to dashboard
    """

    table = boto3.resource('dynamodb', region_name='us-east-2').Table
    handle_auth(request, table)

    for coin_id in range(1, 6):
        coin = shortcuts.get_object_or_404(CoinPrices, pk=coin_id)

        if is_crypto(coin_id):
            curr_price = CryptoApi.get_prices(str(coin.ticker), "usd")['last']
            CoinPrices.objects.filter(pk=coin_id).update(
                current_price=curr_price)
        else:
            last_price = CurrencyRates().get_rates('USD')['GBP']
            CoinPrices.objects.filter(pk=5).update(current_price=last_price)

        response, response_charts = get_response_data(coin, coin_id, table)

        json_data = json.loads((json.dumps(response['Item'],
                                           indent=4,
                                           cls=DecimalEncoder)))
        json_data_charts = json.loads((json.dumps(response_charts['Item'],
                                                  indent=4,
                                                  cls=DecimalEncoder)))

        update_current_trend(coin, coin_id, json_data, json_data_charts)

    all_coins = CoinPrices.objects.all()

    for c in all_coins:
        sentiment = sum(Scraper.analyze_tweets_numerical(c.ticker)[0:3])
        CoinPrices.objects.filter(ticker=c.ticker).update(
            sentiment_score=round(sentiment, 2))

    tables.RequestConfig(request).configure(CoinTable(all_coins))
    return shortcuts.render(
        request, 'dashboard/index.html', {
            'all_coins': all_coins,
            'table': table,
            'equity': round(CryptoApi.get_equity(), 2)
        })
Пример #25
0
def get_currencies_range(since_date, to_date, step=1):
    c = CurrencyRates()
    currencies, dates = [], []
    time_delta = dt.timedelta(days=step)
    index = 0
    while since_date < to_date:
        try:
            currency = c.get_rates("USD", since_date)
            currencies.append(currency)
            dates.append(since_date)
            since_date = since_date + time_delta
            print(index, currencies[index], since_date, to_date)
            index += 1
        except:
            pass
    return currencies, dates
Пример #26
0
def convert():
    c = CurrencyRates()
    value = amountInput.get()
    fromCurrency = in1.get()
    toCurrency = in2.get()
    if value == '':
        messagebox.showerror('Error',
                             'please enter value you want to convert it')
    elif (fromCurrency == "Select" or toCurrency == "Select"):
        messagebox.showerror('Error', 'please select option')
    else:
        res = c.convert(fromCurrency, toCurrency, float(value))
        result = float('{:.4f}'.format(res))
        #print(result)
        output.delete(0, END)
        output.insert(0, str(result))
Пример #27
0
 def __init__(self, account, instrument, mode, quantity, margin):
     self.account = account
     self.instrument = instrument
     self.mode = mode
     self.quantity = quantity
     self.open_price = account.price_tables[instrument][INVERTED_MODE[
         mode.value]]
     self.target_price = account.price_tables[instrument][mode.value]
     self.spread = abs(self.open_price - self.target_price)
     self.margin = margin
     c = CurrencyRates()
     eur_mult = c.get_rate('EUR', instrument.value[:3])
     self.conv_rate = eur_mult * \
         c.get_rate(instrument.value[:3], instrument.value[3:])
     self.used_funds = margin * quantity / \
         self.conv_rate * self.target_price
def RealTimeCurrencyConversion():
    c = CurrencyRates()

    from_currency = FromCurrency_option.get()
    to_currency = ToCurrency_option.get()

    if (value.get() == ""):
        tkinter.messagebox.showerror("Error", "Amount not entered")

    elif (from_currency == "Select" or to_currency == "Select"):
        tkinter.messagebox.showerror("Error", "Currency not selected")

    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))
Пример #29
0
def change_money(val1, val2, money, tup, history):
    c = CurrencyRates()
    if tup == ():
        a = c.convert(val1, val2, money)
        s = 'Конвертировал ' + str(money) + ' ' + val1 + ' в ' + val2
        s += ' по курсу ' + str(c.get_rate(val1, val2)) + ' и получил '
        s += str(a) + ' ' + val2
        history.append(s)
        return a
    else:
        a = c.convert(val1, val2, money, tup)
        s = 'Конвертировал ' + str(money) + ' ' + val1 + ' в ' + val2
        s += ' по курсу ' + str(c.get_rate(val1, val2, tup)) + ' и получил '
        s += str(a) + ' ' + val2
        history.append(s)
        return a
Пример #30
0
def get_coinbase_values():
    """Get totals for each crypto from binance and convert to USD/GBP"""

    mydict = lambda: defaultdict(mydict)
    result = mydict()
    currency = CurrencyRates()
    all_accounts = {}
    with restrict_timeout(5, name="coinbase accounts"):  # allow to run for only 5 seconds
        all_accounts = CLIENT.get_accounts()
    if not all_accounts:
        raise ReadTimeout

    json_accounts = json.loads(str(all_accounts))
    gbp_totals = 0
    usd_totals = 0
    btc_totals = 0
    rates = CLIENT.get_exchange_rates()["rates"]
    for account in json_accounts["data"]:
        if "0.00" not in account["balance"]["amount"]:  #if account has a balance
            current_count = account["balance"]["amount"]  # count of current currency
            result["coinbase"][account["currency"]]["count"] = current_count

            # amount in GBP
            current_gbp = account["native_balance"]["amount"]
            gbp_totals += float(current_gbp)
            result["coinbase"][account["currency"]]["GBP"] = current_gbp

            # amount in USD
            current_usd = float(currency.get_rate("GBP", "USD")) * float(current_gbp)
            usd_totals += float(current_usd)
            result["coinbase"][account["currency"]]["USD"] = current_usd

            # amount in BTC
            current_btc = current_count if account["currency"] == "BTC" else \
                    float(current_usd) * float(rates["BTC"]) # USD -> BTC
            btc_totals += float(current_btc)
            result["coinbase"][account["currency"]]["BTC"] = current_btc


            result["coinbase"]["TOTALS"]["BTC"] = btc_totals
            result["coinbase"]["TOTALS"]["USD"] = usd_totals
            result["coinbase"]["TOTALS"]["GBP"] = gbp_totals
            result["coinbase"]["TOTALS"]["count"] = ""

    #print json.dumps(json_accounts["data"][3])

    return default_to_regular(result)