def getAllMarkets(limit=None): cap = Market() if not limit: stats = cap.stats() limit = stats['active_currencies'] + stats['active_assets'] return cap.ticker(limit=limit)
def get_market_cap(): try: coinmarketcap = Market() except: return 'Неполадки на сервере coinmarketcap' request = coinmarketcap.stats() return 'Market Cap: ' + str( round(request['total_market_cap_usd'] / 1000000000, 3)) + ' B'
def get_market(): try: coinmarketcap = Market() except: return 'Неполадки на сервере coinmarketcap' request = coinmarketcap.stats() return '*Market Cap:* ' + str(round(request['total_market_cap_usd'] / 1000000000, 3)) + ' B' + '\n' + \ '24h Vol: ' + str(round(request['total_24h_volume_usd'] / 1000000000, 3)) + ' B' + '\n' + \ 'BTC Dominance: ' + str(round(request['bitcoin_percentage_of_market_cap'], 2)) + '%' + '\n' + \ 'Active currencies: ' + str(int(request['active_currencies']))
def refresh(self): coinmarketcap = Market() dict = coinmarketcap.stats() rows = [] for key, value in dict.items(): rows.append((key, value, 0)) data = pd.DataFrame(data=rows, columns=['key', 'value', 'index']) self.__dataframe = data.pivot(columns='key', values='value', index='index') self.__dataframe['insertion_time'] = self. __insertion_time
import urllib.request from bs4 import BeautifulSoup from goose3 import Goose from coinmarketcap import Market coinmarketcap = Market() stat = coinmarketcap.ticker(start=0, limit=10) pv = [] pl = [] pv2 = [] for i in stat: pl.append(i["id"]) pv.append(i["market_cap_usd"]) #print(stat[0]['id']) #print(pv) stat1 = coinmarketcap.stats() bitcoin_per = stat1["bitcoin_percentage_of_market_cap"] #print(bitcoin_per) bit = coinmarketcap.ticker('bitcoin') bit_p = bit[0]["market_cap_usd"] #print(bit_p) #print(pv[0].type) for j in range(len(pv)): #print(pv[j]) pv2.append((float(pv[j]) * float(bitcoin_per)) / float(bit_p)) pl.append("Others") pv2.append(100 - sum(pv2))
from coinmarketcap import Market coinmarketcap = Market() alllistings = coinmarketcap.listings() #print(alllistings) getbtcprice = coinmarketcap.ticker(start=1, limit=1, convert='INR') #print(getbtcprice) getpricebyid = coinmarketcap.ticker(1, convert='INR') #print(getpricebyid) getoverallstats = coinmarketcap.stats(convert='INR') #print(getoverallstats)
class CryptoBot(ChatBot): # All the variables related to the new functionalities implemented by the class cryptoBot # __defaultCoin is used to know which will be the coin used to report the value of other coins # __defaultCurrency is used to know which of the fiat currency is going to be used for reporting # __supportedCurrencies will be the list of currencies that coinmarketcap supports in their api # __savedStats is where we are going to store all the information about the main stats in the market # __savedTickers is where we are going to store all the information related to the coins based on their currency # __currencyPerson is where we will store if someone changes their currency and which are they going to use # __lastUpdatedStats is the timestamp of the last update in the stats # __lastUpdatedTickers is the timestamp of the last update in the tickers # __updateInterval is the value in seconds of the minimum amount of time needed to update the stats and tickers again __defaultCoin = "BTC" __defaultCurrency = "USD" __supportedCurrencies = [ "USD", "AUD", "BRL", "CAD", "CHF", "CNY", "EUR", "GBP", "HKD", "IDR", "INR", "JPY", "KRW", "MXN", "RUB" ] __savedStats = {} __savedTickers = {} __currencyPerson = {} __lastUpdatedStats = {} __lastUpdatedTickers = {} __updateInterval = None # __coinMarketCap is the object created by the coinMarketCap api that will get us all the information from them __coinMarketCap = None # __exchangerList is the list of exchanger objects that we will use for the functionalities related to the exchangers __exchangerList = None # Setup of all variables def __init__(self, token, superadminid, adminsid=[], exchangers=[], updateInterval=300, debuglevel=0): super(CryptoBot, self).__init__(token, superadminid, adminsid, debuglevel) self._debugLevel = debuglevel if (self._debugLevel > 0): print "Debug Level: " + str(debuglevel) self.__exchangerList = exchangers self.__updateInterval = updateInterval if (self._debugLevel >= 1): print "Update Interval: " + str(updateInterval) self.__coinmarketcap = Market() for currency in self.__supportedCurrencies: if (self._debugLevel >= 1): print "Supported Currency: " + currency self.__lastUpdatedStats[currency] = datetime.datetime.min self.__lastUpdatedTickers[currency] = datetime.datetime.min self.__getStats(currency) self.__getTickers(currency) if (self._debugLevel >= 1): print "Adding Handlers" self._addCommandHandler('currency', self.__setCurrency, pass_args=True) self._addCommandHandler('fiatPrice', self.__getPriceFiat, pass_args=True) self._addCommandHandler('price', self.__getPriceCoin, pass_args=True) self._addCommandHandler('rank', self.__getRank, pass_args=True) self._addCommandHandler('marketcap', self.__getMarketCap, pass_args=True) self._addCommandHandler('volume', self.__getVolume, pass_args=True) self._addCommandHandler('change1h', self.__getChangeLastHour, pass_args=True) self._addCommandHandler('change24h', self.__getChangeLastDay, pass_args=True) self._addCommandHandler('change7d', self.__getChangeLastSevenDays, pass_args=True) self._addCommandHandler('coinInfo', self.__getInfoCoin, pass_args=True) self._removeHandler(self._unknownHandler) self._addHandler(self._unknownHandler) return # Functions related to bot functionalities with especific exchangers # It will add a new exchanger object to the list of exchangers we already have def addExchanger(self, exchanger): raise NotImplementedError( "You need to implement addExchanger before using it") # It will remove an exchanger object from the list of exchangers we have def removeExchanger(self, exchanger): raise NotImplementedError( "You need to implement removeExchanger before using it") # Function to change the interval between updates def setUpdateInterval(self, interval): self.__updateInterval = interval # Function to get the interval between updates def getUpdateInterval(self): return self.__updateInterval # Function to set an specific user currency def setUserCurrency(self, userid, currency): self.__currencyPerson[userid] = currency # Function to get a user currency settings def getUserCurrency(self, userid): return self.__currencyPerson.get(userid) or self.__defaultCurrency # Related to bot functiuonalities with any info in the coins # Function that will create an alarm in case of a coin prices goes above the price we set def setAlertPriceAbove(self, coin, price, person): raise NotImplementedError( "You need to implement setAlertPriceAbove before using it") # Function that will create an alarm in case of a coin prices goes below the price we set def setAlertPriceBelow(self, coin, price, person): raise NotImplementedError( "You need to implement setAlertPriceBelow before using it") # Function that will remove an alarm def removeAlert(self, alertid, person): raise NotImplementedError( "You need to implement removeAlert before using it") # Information related to coins def getStringInfo(self, coins, currency=None, field=None): if (currency == None): currency = self.__defaultCurrency infoString = "" if (self._debugLevel >= 1): print "Getting String Info" if (self._debugLevel >= 2): print "Field: " + str(field) if (self._debugLevel >= 2): print "Coins: " + str(coins) for coin in coins: info = self.getInfo(coin, currency) priceInFiat = self.getPriceInFiat(coin, currency) priceInCoin = self.getPriceInCoin(coin) marketCap = self.getMarketCap(coin, currency) volume = self.getVolume(coin, currency) change1h = self.getChangeLastHour(coin) change24h = self.getChangeLastDay(coin) change7d = self.getChangeLastSevenDays(coin) if (self._debugLevel >= 2): print "Info: " + str(info) if (info != None): infoString += "Name of coin: " + info['name'] + " [" + info[ 'symbol'] + "]\n" if (field == None): infoString += "Rank: " + info['rank'] + "\n\n" infoString += "Price in " + currency + ": " + priceInFiat + "\n" infoString += "Price in " + self.__defaultCoin + ": " + priceInCoin + "\n\n" infoString += "Market Cap in " + currency + ": " + marketCap + "\n" infoString += "24h Volume in " + currency + ": " + volume + "\n\n" infoString += "Change 1h: " + change1h + "\n" infoString += "Change 24h: " + change24h + "\n" infoString += "Change 7d: " + change7d + "\n\n" elif (field == CoinField.PRICE_FIAT): infoString += "Price in " + currency + ": " + priceInFiat + "\n\n" elif (field == CoinField.PRICE_COIN): infoString += "Price in " + self.__defaultCoin + ": " + priceInCoin + "\n\n" elif (field == CoinField.MARKET_CAP): infoString += "Market Cap in " + currency + ": " + marketCap + "\n\n" elif (field == CoinField.VOLUME): infoString += "24h Volume in " + currency + ": " + volume + "\n\n" elif (field == CoinField.CHANGE_1H): infoString += "Change 1h: " + change1h + "\n\n" elif (field == CoinField.CHANGE_24H): infoString += "Change 24h: " + change24h + "\n\n" elif (field == CoinField.CHANGE_7D): infoString += "Change 7d: " + change7d + "\n\n" elif (field == CoinField.RANK): infoString += "Rank: " + info['rank'] + "\n\n" if (self._debugLevel >= 2): print "String Info: \n" + infoString return infoString # This function will get all the info related to a coin def getInfo(self, coin, currency=None): if (currency == None): currency = self.__defaultCurrency coinTicker = None tickers = self.__getTickers(currency) coin = coin.upper() for ticker in tickers: if (ticker['symbol'].upper() == coin or ticker['name'].upper() == coin or ticker['id'].upper() == coin): coinTicker = ticker if (self._debugLevel >= 3): print "Info: " + str(coinTicker) return coinTicker # The function that will return the price in fiat of certain coin def getRank(self, coin): currency = self.__defaultCurrency coinTicker = self.getInfo(coin, currency) if (coinTicker == None): return None keyRank = "rank" if (self._debugLevel >= 2): print "Rank: " + coinTicker[keyRank] return coinTicker[keyRank] # The function that will return the price in fiat of certain coin def getPriceInFiat(self, coin, currency=None): if (currency == None): currency = self.__defaultCurrency coinTicker = self.getInfo(coin, currency) if (coinTicker == None): return None keyPrice = "price_" + currency.lower() if (self._debugLevel >= 2): print "PriceFiat: " + coinTicker[keyPrice] return coinTicker[keyPrice] # The function that will return the price in btc of certain coin def getPriceInCoin(self, coin): currency = self.__defaultCurrency coinTicker = self.getInfo(coin, currency) if (coinTicker == None): return None keyPrice = "price_" + self.__defaultCoin.lower() if (self._debugLevel >= 2): print "PriceCoin: " + coinTicker[keyPrice] return coinTicker[keyPrice] # The function that will return the market cap of certain coin def getMarketCap(self, coin, currency=None): if (currency == None): currency = self.__defaultCurrency coinTicker = self.getInfo(coin, currency) if (coinTicker == None): return None keyMarketCap = "market_cap_" + currency.lower() if (self._debugLevel >= 2): print "Market Cap: " + coinTicker[keyMarketCap] return coinTicker[keyMarketCap] # The function that will return the last 24h volume of certain coin def getVolume(self, coin, currency=None): if (currency == None): currency = self.__defaultCurrency coinTicker = self.getInfo(coin, currency) if (coinTicker == None): return None keyVolume = "24h_volume_" + currency.lower() if (self._debugLevel >= 2): print "Volume: " + coinTicker[keyVolume] return coinTicker[keyVolume] # The function that will return the change in price of the last 24h of certain coin def getChangeLastDay(self, coin): currency = self.__defaultCurrency coinTicker = self.getInfo(coin, currency) if (coinTicker == None): return None keyChange = "percent_change_24h" if (self._debugLevel >= 2): print "Change 24h: " + coinTicker[keyChange] return coinTicker[keyChange] # The function that will return the change in price of the last 1h of certain coin def getChangeLastHour(self, coin): currency = self.__defaultCurrency coinTicker = self.getInfo(coin, currency) if (coinTicker == None): return None keyChange = "percent_change_1h" if (self._debugLevel >= 2): print "Change 1h: " + coinTicker[keyChange] return coinTicker[keyChange] # The function that will return the change in price of the last 7d of certain coin def getChangeLastSevenDays(self, coin): currency = self.__defaultCurrency coinTicker = self.getInfo(coin, currency) if (coinTicker == None): return None keyChange = "percent_change_7d" if (self._debugLevel >= 2): print "Change 7d: " + coinTicker[keyChange] return coinTicker[keyChange] # Coinmarketcap function wrapper that will helps us to avoid doing a lot of request to get the stats def __getStats(self, currency): currentTime = datetime.datetime.now() lapsedTime = (currentTime - self.__lastUpdatedStats[currency]).total_seconds() if (lapsedTime > self.__updateInterval): if (self._debugLevel >= 1): print "Updating Stats for: " + currency self.__lastUpdatedStats[currency] = currentTime if (currency != self.__defaultCurrency and currency in self.__supportedCurrencies): self.__savedStats[currency] = self.__coinmarketcap.stats( convert=currency) else: self.__savedStats[currency] = self.__coinmarketcap.stats() return self.__savedStats[currency] # Coinmarketcap function wrapper that will helps us to avoid doing a lot of request to get the tickers def __getTickers(self, currency): currentTime = datetime.datetime.now() lapsedTime = (currentTime - self.__lastUpdatedTickers[currency]).total_seconds() if (lapsedTime > self.__updateInterval): if (self._debugLevel >= 1): print "Updating Ticker for: " + currency self.__lastUpdatedTickers[currency] = currentTime if (currency != self.__defaultCurrency): self.__savedTickers[currency] = self.__coinmarketcap.ticker( convert=currency) else: self.__savedTickers[currency] = self.__coinmarketcap.ticker() return self.__savedTickers[currency] # Callback functions that the bot will call after receiving a command def __setCurrency(self, bot, update, args): chatId = update.message.chat_id userId = str(update.message.from_user.id) if (self._debugLevel >= 1): print "Set Currency command" if (self._debugLevel >= 2): print "Args: " + str(args) for currency in args: if (self._debugLevel >= 2): print "Arg: " + currency if (currency in self.__supportedCurrencies): self.setUserCurrency(userId, currency) returningMessage = "Your currency now was set to " + currency if (self._debugLevel >= 1): print "Currency for user " + userId + " set to: " + currency bot.send_message(chat_id=chatId, text=returningMessage) return def __getRank(self, bot, update, args): chatId = update.message.chat_id userId = str(update.message.from_user.id) currency = self.__currencyPerson.get(userId) field = CoinField.RANK if (self._debugLevel >= 1): print "Get Rank command" if (self._debugLevel >= 2): print "Args: " + str(args) returningMessage = self.getStringInfo(args, currency, field) bot.send_message(chat_id=chatId, text=returningMessage) return def __getPriceFiat(self, bot, update, args): chatId = update.message.chat_id userId = str(update.message.from_user.id) currency = self.__currencyPerson.get(userId) field = CoinField.PRICE_FIAT if (self._debugLevel >= 1): print "Get Price Fiat command" if (self._debugLevel >= 2): print "Args: " + str(args) returningMessage = self.getStringInfo(args, currency, field) bot.send_message(chat_id=chatId, text=returningMessage) return def __getPriceCoin(self, bot, update, args): chatId = update.message.chat_id userId = str(update.message.from_user.id) currency = self.__currencyPerson.get(userId) field = CoinField.PRICE_COIN if (self._debugLevel >= 1): print "Get Price Coin command" if (self._debugLevel >= 2): print "Args: " + str(args) returningMessage = self.getStringInfo(args, currency, field) bot.send_message(chat_id=chatId, text=returningMessage) return def __getMarketCap(self, bot, update, args): chatId = update.message.chat_id userId = str(update.message.from_user.id) currency = self.__currencyPerson.get(userId) field = CoinField.MARKET_CAP if (self._debugLevel >= 1): print "Get Market Cap coomand" if (self._debugLevel >= 2): print "Args: " + str(args) returningMessage = self.getStringInfo(args, currency, field) bot.send_message(chat_id=chatId, text=returningMessage) return def __getVolume(self, bot, update, args): chatId = update.message.chat_id userId = str(update.message.from_user.id) currency = self.__currencyPerson.get(userId) field = CoinField.VOLUME if (self._debugLevel >= 1): print "Get Volume command" if (self._debugLevel >= 2): print "Args: " + str(args) returningMessage = self.getStringInfo(args, currency, field) bot.send_message(chat_id=chatId, text=returningMessage) return def __getChangeLastDay(self, bot, update, args): chatId = update.message.chat_id userId = str(update.message.from_user.id) currency = self.__currencyPerson.get(userId) field = CoinField.CHANGE_24H if (self._debugLevel >= 1): print "Get Change 24h command" if (self._debugLevel >= 2): print "Args: " + str(args) returningMessage = self.getStringInfo(args, currency, field) bot.send_message(chat_id=chatId, text=returningMessage) return def __getChangeLastHour(self, bot, update, args): chatId = update.message.chat_id userId = str(update.message.from_user.id) currency = self.__currencyPerson.get(userId) field = CoinField.CHANGE_1H if (self._debugLevel >= 1): print "Get Change 1h command" if (self._debugLevel >= 2): print "Args: " + str(args) returningMessage = self.getStringInfo(args, currency, field) bot.send_message(chat_id=chatId, text=returningMessage) return def __getChangeLastSevenDays(self, bot, update, args): chatId = update.message.chat_id userId = str(update.message.from_user.id) currency = self.__currencyPerson.get(userId) field = CoinField.CHANGE_7D if (self._debugLevel >= 1): print "Get Change 7d command" if (self._debugLevel >= 2): print "Args: " + str(args) returningMessage = self.getStringInfo(args, currency, field) bot.send_message(chat_id=chatId, text=returningMessage) return def __getInfoCoin(self, bot, update, args): chatId = update.message.chat_id userId = str(update.message.from_user.id) currency = self.__currencyPerson.get(userId) if (self._debugLevel >= 1): print "Get Info command" if (self._debugLevel >= 2): print "Args: " + str(args) returningMessage = self.getStringInfo(args, currency) bot.send_message(chat_id=chatId, text=returningMessage) return
from coinmarketcap import Market from datetime import datetime from decimal import Decimal from blockchain import statistics import pandas as pd import requests coinmarketcap = Market() cnmc_stats = coinmarketcap.stats(convert='USD') cnmc_ticker = coinmarketcap.ticker(start=0, limit=1, convert='USD') # CoinMarketCap DATA last_updated = datetime.fromtimestamp( int(cnmc_ticker['data']['1']['last_updated'])).strftime( '%Y-%m-%d %H:%M:%S') btc_price_cmc = cnmc_ticker['data']['1']['quotes']['USD']['price'] btc_volume_24h_cmc = cnmc_ticker['data']['1']['quotes']['USD']['volume_24h'] btc_market_cap = cnmc_ticker['data']['1']['quotes']['USD']['market_cap'] btc_percent_change_1h = cnmc_ticker['data']['1']['quotes']['USD'][ 'percent_change_1h'] btc_percent_change_24h = cnmc_ticker['data']['1']['quotes']['USD'][ 'percent_change_24h'] btc_percent_change_7d = cnmc_ticker['data']['1']['quotes']['USD'][ 'percent_change_7d'] supply_percentage = Decimal(cnmc_ticker['data']['1']['total_supply'] / cnmc_ticker['data']['1']['max_supply']) btc_dominance = cnmc_stats['data']['bitcoin_percentage_of_market_cap'] total_market_cap = cnmc_stats['data']['quotes']['USD']['total_market_cap'] # Crypto Whale MARKET INFRO - Twitter # Blockchain Data stats = statistics.get() btc_trade_volume = stats.trade_volume_btc
class CoinMarket: """Handles CoinMarketCap API features""" def __init__(self): """ Initiates CoinMarket @param bot - discord bot object """ self.market = Market() def fiat_check(self, fiat): """ Checks if fiat is valid. If invalid, raise FiatException error. @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - uppercase fiat """ if fiat is not fiat.upper(): fiat = fiat.upper() if fiat not in fiat_currencies: error_msg = "This fiat currency is not supported: `{}`".format( fiat) raise FiatException(error_msg) return fiat def format_price(self, price, fiat, symbol=True): """ Formats price under the desired fiat @param price - price to format @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @param symbol - if True add currency symbol to fiat if False symbol will not be added @return - formatted price under fiat """ c = CurrencyConverter() ucase_fiat = fiat.upper() price = float(c.convert(float(price), "USD", fiat)) if symbol: if ucase_fiat in fiat_suffix: formatted_fiat = "{:,.6f} {}".format( float(price), fiat_currencies[ucase_fiat]) else: formatted_fiat = "{}{:,.6f}".format( fiat_currencies[ucase_fiat], float(price)) else: formatted_fiat = str(price) formatted_fiat = formatted_fiat.rstrip('0') if formatted_fiat.endswith('.'): formatted_fiat = formatted_fiat.replace('.', '') return formatted_fiat def fetch_currency_data(self, currency="", fiat="", load_all=False): """ Fetches the currency data based on the desired currency @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @param load_all - True: load all cryptocurrencies False: don't load all cryptocurrencies @return - currency data """ try: if load_all: return self.market.ticker(start=0, limit=0) return self.market.ticker(currency, convert=fiat) except RequestException as e: logger.error("Failed to retrieve data - " "Connection error: {}".format(str(e))) return None except Exception as e: raise CurrencyException("Failed to find currency: `{}`. Check " "if this currency is valid and also check " "for spelling errors: {}".format( currency, str(e))) def _format_currency_data(self, data, eth_price, fiat, single_search=True): """ Formats the data fetched @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @param single_search - separate more lines if True @return - formatted currency data """ try: price = CurrencyConverter() isPositivePercent = True formatted_data = '' hour_trend = '' if data['percent_change_24h'] is not None: if float(data['percent_change_24h']) >= 0: hour_trend = SMALL_GREEN_TRIANGLE else: hour_trend = SMALL_RED_TRIANGLE isPositivePercent = False header = "__**#{}. {} ({})**__ {}".format(data['rank'], data['name'], data['symbol'], hour_trend) converted_price = float( price.convert(float(data['price_usd']), 'USD', fiat)) converted_price = "{:,.6f}".format(converted_price).rstrip('0') if converted_price.endswith('.'): converted_price = converted_price.replace('.', '') formatted_btc = '{:,.8f}'.format(float( data['price_btc'])).rstrip('0') if formatted_btc.endswith('.'): formatted_btc = formatted_btc.replace('.', '') eth_price = eth_price.rstrip('.') if single_search: eth_price += '\n' if data['market_cap_usd'] is None: formatted_market_cap = 'Unknown' else: converted_market_cap = price.convert( float(data['market_cap_usd']), 'USD', fiat) if fiat in fiat_suffix: formatted_price = '**{} {}**'.format(converted_price, fiat_currencies[fiat]) if data['market_cap_usd'] is not None: formatted_market_cap = '**{:,} {}**'.format( int(converted_market_cap), fiat_currencies[fiat]) else: formatted_price = '**{}{}**'.format(fiat_currencies[fiat], converted_price) if data['market_cap_usd'] is not None: formatted_market_cap = '**{}{:,}**'.format( fiat_currencies[fiat], int(converted_market_cap)) if (data['available_supply'] is None): available_supply = 'Unknown' else: available_supply = '**{:,}**'.format( int(float(data['available_supply']))) if single_search: available_supply += '\n' percent_change_1h = '**{}%**'.format(data['percent_change_1h']) percent_change_24h = '**{}%**'.format(data['percent_change_24h']) percent_change_7d = '**{}%**'.format(data['percent_change_7d']) formatted_data = ("{}\n" "Price ({}): {}\n" "Price (BTC): **{}**\n" "Price (ETH): **{}**\n" "Market Cap ({}): {}\n" "Available Supply: {}\n" "Percent Change (1H): {}\n" "Percent Change (24H): {}\n" "Percent Change (7D): {}\n" "".format(header, fiat, formatted_price, formatted_btc, eth_price, fiat, formatted_market_cap, available_supply, percent_change_1h, percent_change_24h, percent_change_7d)) return formatted_data, isPositivePercent except Exception as e: raise CoinMarketException("Failed to format data ({}): {}".format( data['name'], e)) def get_currency(self, acronym_list, currency, fiat): """ Obtains the data of the specified currency and returns them. @param acronym_list - list of cryptocurrency acronyms @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') """ try: isPositivePercent = False fiat = self.fiat_check(fiat) if currency.upper() in acronym_list: try: data = self.fetch_currency_data( acronym_list[currency.upper()], fiat)[0] except CurrencyException: formatted_data = acronym_list[currency.upper()] return formatted_data, isPositivePercent else: data = self.fetch_currency_data(currency, fiat)[0] formatted_data, isPositivePercent = self._format_currency_data( data, fiat) return formatted_data, isPositivePercent except CurrencyException as e: raise except FiatException as e: raise except Exception as e: raise CoinMarketException(e) def get_current_currency(self, market_list, acronym_list, currency, fiat): """ Obtains the data of the specified currency and returns them using the current updated market list @param market_list - list of entire crypto market @param acronym_list - list of cryptocurrency acronyms @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') """ try: isPositivePercent = False fiat = self.fiat_check(fiat) if currency.upper() in acronym_list: currency = acronym_list[currency.upper()] if "Duplicate" in currency: return currency, isPositivePercent if currency not in market_list: raise CurrencyException( "Invalid currency: `{}`".format(currency)) data = market_list[currency] eth_price = self.get_converted_coin_amt(market_list, currency, ETHEREUM, 1) formatted_data, isPositivePercent = self._format_currency_data( data, eth_price, fiat) return formatted_data, isPositivePercent except CurrencyException as e: raise except FiatException as e: raise except Exception as e: raise CoinMarketException(e) def fetch_coinmarket_stats(self, fiat=''): """ Fetches the coinmarket stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - market stats """ try: return self.market.stats(convert=fiat) except RequestException as e: logger.error("Failed to retrieve data - " "Connection error: {}".format(str(e))) return None except Exception as e: raise MarketStatsException( "Unable to retrieve crypto market stats " "at this time.") def _format_coinmarket_stats(self, stats, fiat): """ Receives and formats coinmarket stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted stats """ try: c = CurrencyConverter() formatted_stats = '' if (stats['total_market_cap_usd'] is None): formatted_stats += "Total Market Cap (USD): Unknown" else: converted_price = int( c.convert(float(stats['total_market_cap_usd']), 'USD', fiat)) if fiat in fiat_suffix: formatted_stats += "Total Market Cap ({}): **{:,} {}**\n".format( fiat, converted_price, fiat_currencies[fiat]) else: formatted_stats += "Total Market Cap ({}): **{}{:,}**\n".format( fiat, fiat_currencies[fiat], converted_price) formatted_stats += "Bitcoin Percentage of Market: **{:,}%**\n".format( stats['bitcoin_percentage_of_market_cap']) formatted_stats += "Active Markets: **{:,}**\n".format( stats['active_markets']) formatted_stats += "Active Currencies: **{:,}**\n".format( stats['active_currencies']) formatted_stats += "Active Assets: **{:,}**\n".format( stats['active_assets']) return formatted_stats except Exception as e: raise CoinMarketException("Failed to format data: `{}`".format(e)) def get_stats(self, fiat): """ Returns the market stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted market stats """ try: fiat = self.fiat_check(fiat) stats = self.fetch_coinmarket_stats(fiat) formatted_stats = self._format_coinmarket_stats(stats, fiat) return formatted_stats except FiatException as e: raise except MarketStatsException as e: raise except Exception as e: raise CoinMarketException(e) def get_current_stats(self, market_stats, fiat): """ Returns the market stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted market stats """ try: fiat = self.fiat_check(fiat) formatted_stats = self._format_coinmarket_stats(market_stats, fiat) return formatted_stats except FiatException as e: raise except MarketStatsException as e: raise except Exception as e: raise CoinMarketException(e) def get_multiple_currency(self, acronym_list, currency_list, fiat): """ Returns updated info of multiple coin stats @param acronym_list - list of cryptocurrency acronyms @param currency_list - list of cryptocurrencies @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted cryptocurrency data """ try: fiat = self.fiat_check(fiat) formatted_data = '' data_list = [] for currency in currency_list: if acronym_list is not None: if currency.upper() in acronym_list: data_list.append( self.fetch_currency_data( acronym_list[currency.upper()], fiat)[0]) else: data_list.append( self.fetch_currency_data(currency, fiat)[0]) else: data_list.append( self.fetch_currency_data(currency, fiat)[0]) data_list.sort(key=lambda x: int(x['rank'])) for data in data_list: formatted_data += self._format_currency_data( data, fiat, False)[0] + '\n' return formatted_data except CurrencyException as e: raise except FiatException as e: raise except Exception as e: raise CoinMarketException(e) def get_current_multiple_currency(self, market_list, acronym_list, currency_list, fiat, cached_data=None): """ Returns updated info of multiple coin stats using the current updated market list @param market_list - list of entire crypto market @param acronym_list - list of cryptocurrency acronyms @param cached_data - a cache of formatted cryptocurrency data @param currency_list - list of cryptocurrencies to retrieve @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - list of formatted cryptocurrency data """ try: formatted_data = [] data_list = [] result_msg = '' for currency in currency_list: try: if acronym_list is not None: if currency.upper() in acronym_list: currency = acronym_list[currency.upper()] if "Duplicate" in currency: return [[currency]] if market_list[currency] not in data_list: data_list.append(market_list[currency]) else: if market_list[currency] not in data_list: data_list.append(market_list[currency]) except: raise CurrencyException("Invalid currency: `{}`" "".format(currency)) data_list.sort(key=lambda x: int(x['rank'])) for data in data_list: eth_price = self.get_converted_coin_amt( market_list, data['id'], ETHEREUM, 1) if cached_data is None: formatted_msg = self._format_currency_data( data, eth_price, fiat, False)[0] else: if cached_data: if fiat not in cached_data: cached_data[fiat] = {} if data['id'] not in cached_data[fiat]: formatted_msg = self._format_currency_data( data, eth_price, fiat, False)[0] cached_data[fiat][data['id']] = formatted_msg else: formatted_msg = cached_data[fiat][data['id']] else: formatted_msg = self._format_currency_data( data, eth_price, fiat, False)[0] if fiat not in cached_data: cached_data[fiat] = {} if data['id'] not in cached_data[fiat]: cached_data[fiat][data['id']] = formatted_msg if len(result_msg) + len(formatted_msg) < 2000: result_msg += "{}\n".format(formatted_msg) else: formatted_data.append(result_msg) result_msg = formatted_msg formatted_data.append(result_msg) return formatted_data, cached_data except CurrencyException as e: raise except FiatException as e: raise except Exception as e: raise CoinMarketException(e) def get_converted_coin_amt(self, market_list, currency1, currency2, currency_amt): """ Converts coin to coin based on btc price """ try: price_btc1 = float(market_list[currency1]['price_btc']) price_btc2 = float(market_list[currency2]['price_btc']) btc_amt = float("{:.8f}".format(currency_amt * price_btc1)) converted_amt = "{:.8f}".format(btc_amt / price_btc2).rstrip('0') return converted_amt except Exception as e: print("Failed to convert coin. See error.log.") logger.error("Exception: {}".format(str(e)))
class CoinMarket: """Handles CoinMarketCap API features""" def __init__(self): """ Initiates CoinMarket @param bot - discord bot object """ self.market = Market() def fiat_check(self, fiat): """ Checks if fiat is valid. If invalid, raise FiatException error. @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - uppercase fiat """ if fiat is not fiat.upper(): fiat = fiat.upper() if fiat not in fiat_currencies: error_msg = "This fiat currency is not supported: `{}`".format( fiat) raise FiatException(error_msg) return fiat def format_price(self, price, fiat, symbol=True): """ Formats price under the desired fiat @param price - price to format @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @param symbol - if True add currency symbol to fiat if False symbol will not be added @return - formatted price under fiat """ c = CurrencyConverter() ucase_fiat = fiat.upper() if fiat is not "USD": price = float(c.convert(float(price), "USD", fiat)) if symbol: if ucase_fiat in fiat_suffix: formatted_fiat = "{:,.6f} {}".format( float(price), fiat_currencies[ucase_fiat]) else: formatted_fiat = "{}{:,.6f}".format( fiat_currencies[ucase_fiat], float(price)) else: formatted_fiat = str(price) formatted_fiat = formatted_fiat.rstrip('0') if formatted_fiat.endswith('.'): formatted_fiat = formatted_fiat.replace('.', '') return formatted_fiat def fetch_currency_data(self, currency="", fiat="", load_all=False): """ Fetches the currency data based on the desired currency @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @param load_all - True: load all cryptocurrencies False: don't load all cryptocurrencies @return - currency data """ try: if load_all: return self.market.ticker(start=0, limit=0) return self.market.ticker(currency, convert=fiat) except Exception as e: raise CurrencyException("Failed to find currency: `{}`. Check " "if this currency is valid and also check " "for spelling errors.".format(currency)) def _format_currency_data(self, data, fiat): """ Formats the data fetched @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted currency data """ try: price = CurrencyConverter() isPositivePercent = True formatted_data = '' hour_trend = '' if float(data['percent_change_1h']) >= 0: hour_trend = '<:small_green_triangle:396586561413578752>' else: hour_trend = ':small_red_triangle_down:' isPositivePercent = False formatted_data += '__**#{}. {} ({})**__ {}\n'.format( data['rank'], data['name'], data['symbol'], hour_trend) if fiat is not "USD": converted_price = float( price.convert(float(data['price_usd']), 'USD', fiat)) converted_price = "{:,.6f}".format(converted_price).rstrip('0') if converted_price.endswith('.'): converted_price = converted_price.replace('.', '') if fiat in fiat_suffix: formatted_data += 'Price ({}): **{} {}**\n'.format( fiat, converted_price, fiat_currencies[fiat]) else: formatted_data += 'Price ({}): **{}{}**\n'.format( fiat, fiat_currencies[fiat], converted_price) formatted_data += 'Price (BTC): **{:,}**\n'.format( float(data['price_btc'])) if (data['market_cap_usd'] is None): formatted_data += 'Market Cap ({}): Unknown\n'.format(fiat) else: converted_price = float( price.convert(float(data['market_cap_usd']), 'USD', fiat)) formatted_data += 'Market Cap ({}): **${:,}**\n'.format( fiat, converted_price) if (data['available_supply'] is None): formatted_data += 'Available Supply: Unknown\n' else: formatted_data += 'Available Supply: **{:,}**\n'.format( float(data['available_supply'])) formatted_data += 'Percent Change (1H): **{}%**\n'.format( data['percent_change_1h']) formatted_data += 'Percent Change (24H): **{}%**\n'.format( data['percent_change_24h']) formatted_data += 'Percent Change (7D): **{}%**\n'.format( data['percent_change_7d']) return formatted_data, isPositivePercent except Exception as e: raise CoinMarketException("Failed to format data: {}".format(e)) def get_currency(self, acronym_list, currency, fiat): """ Obtains the data of the specified currency and returns them. @param acronym_list - list of cryptocurrency acronyms @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') """ try: isPositivePercent = False fiat = self.fiat_check(fiat) if currency.upper() in acronym_list: try: data = self.fetch_currency_data( acronym_list[currency.upper()], fiat)[0] except CurrencyException: formatted_data = acronym_list[currency.upper()] return formatted_data, isPositivePercent else: data = self.fetch_currency_data(currency, fiat)[0] formatted_data, isPositivePercent = self._format_currency_data( data, fiat) return formatted_data, isPositivePercent except CurrencyException as e: raise except FiatException as e: raise except Exception as e: raise CoinMarketException(e) def get_current_currency(self, market_list, acronym_list, currency, fiat): """ Obtains the data of the specified currency and returns them using the current updated market list @param market_list - list of entire crypto market @param acronym_list - list of cryptocurrency acronyms @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') """ try: isPositivePercent = False fiat = self.fiat_check(fiat) if currency.upper() in acronym_list: currency = acronym_list[currency.upper()] if "Duplicate" in currency: return currency, isPositivePercent if currency not in market_list: raise CurrencyException( "Invalid currency: `{}`".format(currency)) data = market_list[currency] formatted_data, isPositivePercent = self._format_currency_data( data, fiat) return formatted_data, isPositivePercent except CurrencyException as e: raise except FiatException as e: raise except Exception as e: raise CoinMarketException(e) def fetch_coinmarket_stats(self, fiat=''): """ Fetches the coinmarket stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - market stats """ try: return self.market.stats(convert=fiat) except Exception as e: raise MarketStatsException( "Unable to retrieve crypto market stats " "at this time.") def _format_coinmarket_stats(self, stats, fiat): """ Receives and formats coinmarket stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted stats """ try: c = CurrencyConverter() formatted_stats = '' if (stats['total_market_cap_usd'] is None): formatted_stats += "Total Market Cap (USD): Unknown" else: if fiat is not "USD": converted_price = c.convert( float(stats['total_market_cap_usd']), 'USD', fiat) if fiat in fiat_suffix: formatted_stats += "Total Market Cap ({}): **{:,} {}**\n".format( fiat, converted_price, fiat_currencies[fiat]) else: formatted_stats += "Total Market Cap ({}): **{}{:,}**\n".format( fiat, fiat_currencies[fiat], converted_price) formatted_stats += "Bitcoin Percentage of Market: **{:,}%**\n".format( stats['bitcoin_percentage_of_market_cap']) formatted_stats += "Active Markets: **{:,}**\n".format( stats['active_markets']) formatted_stats += "Active Currencies: **{:,}**\n".format( stats['active_currencies']) formatted_stats += "Active Assets: **{:,}**\n".format( stats['active_assets']) return formatted_stats except Exception as e: raise CoinMarketException("Failed to format data: `{}`".format(e)) def get_stats(self, fiat): """ Returns the market stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted market stats """ try: fiat = self.fiat_check(fiat) stats = self.fetch_coinmarket_stats(fiat) formatted_stats = self._format_coinmarket_stats(stats, fiat) return formatted_stats except FiatException as e: raise except MarketStatsException as e: raise except Exception as e: raise CoinMarketException(e) def get_current_stats(self, market_stats, fiat): """ Returns the market stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted market stats """ try: fiat = self.fiat_check(fiat) formatted_stats = self._format_coinmarket_stats(market_stats, fiat) return formatted_stats except FiatException as e: raise except MarketStatsException as e: raise except Exception as e: raise CoinMarketException(e) def get_multiple_currency(self, acronym_list, currency_list, fiat): """ Returns updated info of multiple coin stats @param acronym_list - list of cryptocurrency acronyms @param currency_list - list of cryptocurrencies @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted cryptocurrency data """ try: fiat = self.fiat_check(fiat) formatted_data = '' data_list = [] for currency in currency_list: if acronym_list is not None: if currency.upper() in acronym_list: data_list.append( self.fetch_currency_data( acronym_list[currency.upper()], fiat)[0]) else: data_list.append( self.fetch_currency_data(currency, fiat)[0]) else: data_list.append( self.fetch_currency_data(currency, fiat)[0]) data_list.sort(key=lambda x: int(x['rank'])) for data in data_list: formatted_data += self._format_currency_data(data, fiat)[0] + '\n' return formatted_data except CurrencyException as e: raise except FiatException as e: raise except Exception as e: raise CoinMarketException(e) def get_current_multiple_currency(self, market_list, acronym_list, currency_list, fiat): """ Returns updated info of multiple coin stats using the current updated market list @param market_list - list of entire crypto market @param acronym_list - list of cryptocurrency acronyms @param currency_list - list of cryptocurrencies to retrieve @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - list of formatted cryptocurrency data """ try: fiat = self.fiat_check(fiat) formatted_data = [] data_list = [] result_msg = '' for currency in currency_list: try: if currency.upper() in acronym_list: currency = acronym_list[currency.upper()] if "Duplicate" in currency: return currency data_list.append(market_list[currency]) except: raise CurrencyException( "Invalid currency: `{}`".format(currency)) data_list.sort(key=lambda x: int(x['rank'])) for data in data_list: formatted_msg = self._format_currency_data(data, fiat)[0] if len(result_msg + formatted_msg) < 2000: result_msg += formatted_msg + '\n' else: formatted_data.append(result_msg) result_msg = '{}'.format(formatted_msg) formatted_data.append(result_msg) return formatted_data except CurrencyException as e: raise except FiatException as e: raise except Exception as e: raise CoinMarketException(e)
class CoinMarket: """ Handles CoinMarketCap API features """ def __init__(self): """ Initiates CoinMarket @param bot - discord bot object """ self.market = Market() def fiat_check(self, fiat): """ Checks if fiat is valid. If invalid, raise FiatException error. @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - uppercase fiat """ if fiat is not fiat.upper(): fiat = fiat.upper() if fiat not in fiat_currencies: error_msg = "This fiat currency is not supported: `{}`".format( fiat) raise FiatException(error_msg) return fiat def format_price(self, price, fiat): """ Formats price under the desired fiat @param price - price to format @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted price under fiat """ ucase_fiat = fiat.upper() if ucase_fiat in fiat_suffix: formatted_fiat = "{:,.2f} {}".format(float(price), fiat_currencies[ucase_fiat]) else: formatted_fiat = "{}{:,.2f}".format(fiat_currencies[ucase_fiat], float(price)) return formatted_fiat def load_all_acronyms(self): """ Loads all available acronyms for cryptocurrencies @return - all cryptocurrency acronyms """ try: acronym_list = {} duplicate_count = 0 data = self.fetch_currency_data(load_all=True) for currency in data: if currency['symbol'] in acronym_list: duplicate_count += 1 logger.warning( "Found duplicate acronym. Creating seperate " "separate definition...") if currency['symbol'] not in acronym_list[ currency['symbol']]: acronym_list[currency['symbol'] + str(1)] = acronym_list[currency['symbol']] acronym_list[currency['symbol']] = ( "Duplicate acronyms " "found. Possible " "searches are:\n" "{}1 ({})\n".format( currency['symbol'], acronym_list[currency['symbol']])) dupe_acronym = re.search('\\d+', acronym_list[currency['symbol']]) dupe_num = str( int(dupe_acronym.group(len(dupe_acronym.group()) - 1)) + 1) dupe_key = currency['symbol'] + dupe_num acronym_list[dupe_key] = currency['id'] acronym_list[currency['symbol']] = ( acronym_list[currency['symbol']] + "{} ({})".format(dupe_key, currency['id'])) dupe_msg = "Created duplicate acronym: {} ({})".format( dupe_key, currency['id']) logger.info(dupe_msg) else: acronym_list[currency['symbol']] = currency['id'] return acronym_list, duplicate_count except Exception as e: raise CoinMarketException( "Failed to load all acronyms: {}".format(e)) def fetch_currency_data(self, currency="", fiat="", load_all=False): """ Fetches the currency data based on the desired currency @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @param load_all - True: load all cryptocurrencies False: don't load all cryptocurrencies @return - currency data """ try: if load_all: return self.market.ticker(currency, start=0, limit=0) return self.market.ticker(currency, convert=fiat) except Exception: raise CurrencyException("Failed to find currency: `{}`. Check " "if this currency is valid and also check " "for spelling errors.".format(currency)) def _format_currency_data(self, data, fiat): """ Formats the data fetched @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted currency data """ try: isPositivePercent = True formatted_data = '' hour_trend = '' if float(data['percent_change_1h']) >= 0: hour_trend = ':arrow_upper_right:' else: hour_trend = ':arrow_lower_right:' isPositivePercent = False formatted_data += '__**#{}. {} ({})**__ {}\n'.format( data['rank'], data['name'], data['symbol'], hour_trend) if fiat in fiat_suffix: formatted_data += 'Price ({}): **{:,} {}**\n'.format( fiat, float(data['price_{}'.format(fiat.lower())]), fiat_currencies[fiat]) else: formatted_data += 'Price ({}): **{}{:,}**\n'.format( fiat, fiat_currencies[fiat], float(data['price_{}'.format(fiat.lower())])) formatted_data += 'Price (BTC): **{:,}**\n'.format( float(data['price_btc'])) if (data['market_cap_usd'] is None): formatted_data += 'Market Cap (USD): Unknown\n' else: formatted_data += 'Market Cap (USD): **${:,}**\n'.format( float(data['market_cap_usd'])) if (data['available_supply'] is None): formatted_data += 'Available Supply: Unknown\n' else: formatted_data += 'Available Supply: **{:,}**\n'.format( float(data['available_supply'])) formatted_data += 'Percent Change (1H): **{}%**\n'.format( data['percent_change_1h']) formatted_data += 'Percent Change (24H): **{}%**\n'.format( data['percent_change_24h']) formatted_data += 'Percent Change (7D): **{}%**\n'.format( data['percent_change_7d']) return formatted_data, isPositivePercent except Exception as e: raise CoinMarketException("Failed to format data: {}".format(e)) async def get_currency(self, acronym_list, currency, fiat): """ Obtains the data of the specified currency and returns them. @param acronym_list - list of cryptocurrency acronyms @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') """ try: isPositivePercent = False fiat = self.fiat_check(fiat) if currency.upper() in acronym_list: try: data = self.fetch_currency_data( acronym_list[currency.upper()], fiat)[0] except CurrencyException: formatted_data = acronym_list[currency.upper()] return formatted_data, isPositivePercent else: data = self.fetch_currency_data(currency, fiat)[0] formatted_data, isPositivePercent = self._format_currency_data( data, fiat) return formatted_data, isPositivePercent except CurrencyException as e: raise except FiatException as e: raise except Exception as e: raise CoinMarketException(e) def _fetch_coinmarket_stats(self, fiat): """ Fetches the coinmarket stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - market stats """ try: return self.market.stats(convert=fiat) except Exception as e: raise MarketStatsException( "Unable to retrieve crypto market stats " "at this time.") def _format_coinmarket_stats(self, stats, fiat): """ Receives and formats coinmarket stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted stats """ try: formatted_stats = '' if (stats['total_market_cap_usd'] is None): formatted_stats += "Total Market Cap (USD): Unknown" else: if fiat in fiat_suffix: formatted_stats += "Total Market Cap ({}): **{:,} {}**\n".format( fiat, float(stats['total_market_cap_{}'.format( fiat.lower())]), fiat_currencies[fiat]) else: formatted_stats += "Total Market Cap ({}): **{}{:,}**\n".format( fiat, fiat_currencies[fiat], float(stats['total_market_cap_{}'.format( fiat.lower())])) formatted_stats += "Bitcoin Percentage of Market: **{:,}%**\n".format( stats['bitcoin_percentage_of_market_cap']) formatted_stats += "Active Markets: **{:,}**\n".format( stats['active_markets']) formatted_stats += "Active Currencies: **{:,}**\n".format( stats['active_currencies']) formatted_stats += "Active Assets: **{:,}**\n".format( stats['active_assets']) return formatted_stats except Exception as e: raise CoinMarketException("Failed to format data: `{}`".format(e)) async def get_stats(self, fiat): """ Returns the market stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted market stats """ try: fiat = self.fiat_check(fiat) stats = self._fetch_coinmarket_stats(fiat) formatted_stats = self._format_coinmarket_stats(stats, fiat) return formatted_stats except FiatException as e: raise except MarketStatsException as e: raise except Exception as e: raise CoinMarketException(e) async def get_multiple_currency(self, acronym_list, currency_list, fiat): """ Returns updated info of multiple coin stats @param acronym_list - list of cryptocurrency acronyms @param currency_list - list of cryptocurrencies @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted cryptocurrency data """ try: fiat = self.fiat_check(fiat) formatted_data = '' data_list = [] for currency in currency_list: if acronym_list is not None: if currency.upper() in acronym_list: data_list.append( self.fetch_currency_data( acronym_list[currency.upper()], fiat)[0]) else: data_list.append( self.fetch_currency_data(currency, fiat)[0]) else: data_list.append( self.fetch_currency_data(currency, fiat)[0]) data_list.sort(key=lambda x: int(x['rank'])) for data in data_list: formatted_data += self._format_currency_data(data, fiat)[0] + '\n' return formatted_data except CurrencyException as e: raise except FiatException as e: raise except Exception as e: raise CoinMarketException(e)
class CoinMarket: """Handles CoinMarketCap API features""" def __init__(self, api_key): """ Initiates CoinMarket """ self.market = Market(api_key) def fiat_check(self, fiat): """ Checks if fiat is valid. If invalid, raise FiatException error. @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - uppercase fiat """ if fiat is not fiat.upper(): fiat = fiat.upper() if fiat not in fiat_currencies: error_msg = "This fiat currency is not supported: `{}`".format( fiat) raise FiatException(error_msg) return fiat def format_price(self, price, fiat, symbol=True): """ Formats price under the desired fiat @param price - price to format @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @param symbol - if True add currency symbol to fiat if False symbol will not be added @return - formatted price under fiat """ c = CurrencyConverter() ucase_fiat = fiat.upper() price = float(c.convert(float(price), "USD", fiat)) if symbol: if ucase_fiat in fiat_suffix: formatted_fiat = "{:,.6f} {}".format( float(price), fiat_currencies[ucase_fiat]) else: formatted_fiat = "{}{:,.6f}".format( fiat_currencies[ucase_fiat], float(price)) else: formatted_fiat = str(price) formatted_fiat = formatted_fiat.rstrip('0') if formatted_fiat.endswith('.'): formatted_fiat = formatted_fiat.replace('.', '') return formatted_fiat def fetch_currency_data(self, fiat="USD"): """ Fetches all cryptocurrency data @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - currency data """ try: return self.market.listings(limit=5000, convert=fiat) except RequestException as e: logger.error("Failed to retrieve data - " "Connection error: {}".format(str(e))) return None except Exception as e: raise CurrencyException( "Failed to fetch all cryptocurrencies: `{}`".format(str(e))) def _format_currency_data(self, data, fiat, single_search=True): """ Formats the data fetched @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @param single_search - separate more lines if True @return - formatted currency data """ try: price = CurrencyConverter() isPositivePercent = True formatted_data = '' hour_trend = '' if data['quote']['USD']['percent_change_24h'] is not None: if float(data['quote']['USD']['percent_change_24h']) >= 0: hour_trend = SMALL_GREEN_TRIANGLE else: hour_trend = SMALL_RED_TRIANGLE isPositivePercent = False header = "[__**#{}. {} ({})**__ {}](https://coinmarketcap.com/currencies/{})".format( data['cmc_rank'], data['name'], data['symbol'], hour_trend, data['slug']) converted_price = float( price.convert(float(data['quote']['USD']['price']), 'USD', fiat)) converted_price = "{:,.6f}".format(converted_price).rstrip('0') if converted_price.endswith('.'): converted_price = converted_price.replace('.', '') # formatted_btc = '{:,.8f}'.format(float(data['price_btc'])).rstrip('0') # if formatted_btc.endswith('.'): # formatted_btc = formatted_btc.replace('.', '') # eth_price = eth_price.rstrip('.') # if single_search: # eth_price += '\n' if data['quote']['USD']['market_cap'] is None: formatted_market_cap = 'Unknown' else: converted_market_cap = price.convert( float(data['quote']['USD']['market_cap']), 'USD', fiat) if data['quote']['USD']['volume_24h'] is None: formatted_volume_24h = 'Unknown' else: converted_volume_24h = price.convert( float(data['quote']['USD']['volume_24h']), 'USD', fiat) if fiat in fiat_suffix: formatted_price = '**{} {}**'.format(converted_price, fiat_currencies[fiat]) if data['quote']['USD']['market_cap'] is not None: formatted_market_cap = '**{:,} {}**'.format( int(converted_market_cap), fiat_currencies[fiat]) if data['quote']['USD']['volume_24h'] is not None: formatted_volume_24h = '**{:,} {}**'.format( int(converted_volume_24h), fiat_currencies[fiat]) else: formatted_price = '**{}{}**'.format(fiat_currencies[fiat], converted_price) if data['quote']['USD']['market_cap'] is not None: formatted_market_cap = '**{}{:,}**'.format( fiat_currencies[fiat], int(converted_market_cap)) if data['quote']['USD']['volume_24h'] is not None: formatted_volume_24h = '**{}{:,}**'.format( fiat_currencies[fiat], int(converted_volume_24h)) if (data['circulating_supply'] is None): circulating_supply = 'Unknown' else: circulating_supply = '**{:,}**'.format( int(float(data['circulating_supply']))) if (data['max_supply'] is None): max_supply = 'Unknown' else: max_supply = '**{:,}**'.format(int(float(data['max_supply']))) if single_search: formatted_volume_24h += '\n' max_supply += '\n' percent_change_1h = '**{}%**'.format( data['quote']['USD']['percent_change_1h']) percent_change_24h = '**{}%**'.format( data['quote']['USD']['percent_change_24h']) percent_change_7d = '**{}%**'.format( data['quote']['USD']['percent_change_7d']) formatted_data = ( "{}\n" "Price ({}): {}\n" # "Price (BTC): **{}**\n" # "Price (ETH): **{}**\n" "Market Cap ({}): {}\n" "Volume 24h ({}): {}\n" "Circulating Supply: {}\n" "Max Supply: {}\n" "Percent Change (1H): {}\n" "Percent Change (24H): {}\n" "Percent Change (7D): {}\n" "".format( header, fiat, formatted_price, # formatted_btc, # eth_price, fiat, formatted_market_cap, fiat, formatted_volume_24h, circulating_supply, max_supply, percent_change_1h, percent_change_24h, percent_change_7d)) return formatted_data, isPositivePercent except Exception as e: raise CoinMarketException("Failed to format data ({}): {}".format( data['name'], e)) def get_current_currency(self, market_list, acronym_list, currency, fiat): """ Obtains the data of the specified currency and returns them using the current updated market list @param market_list - list of entire crypto market @param acronym_list - list of cryptocurrency acronyms @param currency - the cryptocurrency to search for (i.e. 'bitcoin', 'ethereum') @param fiat - desired fiat currency (i.e. 'EUR', 'USD') """ try: isPositivePercent = False fiat = self.fiat_check(fiat) if currency.upper() in acronym_list: currency = acronym_list[currency.upper()] if "Duplicate" in currency: return currency, isPositivePercent, None if currency not in market_list: raise CurrencyException( "Invalid currency: `{}`".format(currency)) data = market_list[currency] # eth_price = self.get_converted_coin_amt(market_list, currency, ETHEREUM, 1) formatted_data, isPositivePercent = self._format_currency_data( data, fiat) id_number = market_list[currency]['id'] return formatted_data, isPositivePercent, id_number except CurrencyException as e: raise except FiatException as e: raise except Exception as e: raise CoinMarketException(e) def fetch_coinmarket_stats(self, fiat="USD"): """ Fetches the coinmarket stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - market stats """ try: return self.market.stats(convert=fiat) except RequestException as e: logger.error("Failed to retrieve data - " "Connection error: {}".format(str(e))) return None except Exception as e: raise MarketStatsException( "Unable to retrieve crypto market stats " "at this time.") def _format_coinmarket_stats(self, stats, fiat): """ Receives and formats coinmarket stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted stats """ try: c = CurrencyConverter() formatted_stats = '' if stats['data']['quote']['USD']['total_market_cap'] is None: formatted_stats += "Total Market Cap (USD): Unknown" else: converted_price = int( c.convert( float( stats['data']['quote']['USD']['total_market_cap']), 'USD', fiat)) if fiat in fiat_suffix: formatted_stats += "Total Market Cap ({}): **{:,} {}**\n".format( fiat, converted_price, fiat_currencies[fiat]) else: formatted_stats += "Total Market Cap ({}): **{}{:,}**\n".format( fiat, fiat_currencies[fiat], converted_price) if stats['data']['quote']['USD']['total_volume_24h'] is None: formatted_stats += "Total Volume 24h (USD): Unknown" else: converted_price = int( c.convert( float( stats['data']['quote']['USD']['total_volume_24h']), 'USD', fiat)) if fiat in fiat_suffix: formatted_stats += "Total Volume 24h ({}): **{:,} {}**\n".format( fiat, converted_price, fiat_currencies[fiat]) else: formatted_stats += "Total Volume 24h ({}): **{}{:,}**\n".format( fiat, fiat_currencies[fiat], converted_price) formatted_stats += "Bitcoin Dominance: **{}%**\n".format( stats['data']['btc_dominance']) formatted_stats += "Ethereum Dominance: **{}%**\n".format( stats['data']['eth_dominance']) formatted_stats += "Active Exchanges: **{:,}**\n".format( stats['data']['active_exchanges']) formatted_stats += "Active Currencies: **{:,}**\n".format( stats['data']['active_cryptocurrencies']) return formatted_stats except Exception as e: raise CoinMarketException("Failed to format data: `{}`".format(e)) def get_current_stats(self, market_stats, fiat): """ Returns the market stats @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - formatted market stats """ try: fiat = self.fiat_check(fiat) formatted_stats = self._format_coinmarket_stats(market_stats, fiat) return formatted_stats except FiatException as e: raise except MarketStatsException as e: raise except Exception as e: raise CoinMarketException(e) def get_current_multiple_currency(self, market_list, acronym_list, currency_list, fiat, cached_data=None): """ Returns updated info of multiple coin stats using the current updated market list @param market_list - list of entire crypto market @param acronym_list - list of cryptocurrency acronyms @param cached_data - a cache of formatted cryptocurrency data @param currency_list - list of cryptocurrencies to retrieve @param fiat - desired fiat currency (i.e. 'EUR', 'USD') @return - list of formatted cryptocurrency data """ try: formatted_data = [] data_list = [] result_msg = '' for currency in currency_list: try: if acronym_list is not None: if currency.upper() in acronym_list: currency = acronym_list[currency.upper()] if "Duplicate" in currency: return [[currency]] if market_list[currency] not in data_list: data_list.append(market_list[currency]) else: if market_list[currency] not in data_list: data_list.append(market_list[currency]) except Exception as e: raise CurrencyException("Invalid currency: `{}`" "".format(currency)) data_list.sort(key=lambda x: int(x['cmc_rank'])) for data in data_list: # eth_price = self.get_converted_coin_amt(market_list, # data['id'], # ETHEREUM, # 1) if cached_data is None: formatted_msg = self._format_currency_data( data, # eth_price, fiat, False)[0] else: if cached_data: if fiat not in cached_data: cached_data[fiat] = {} if data['id'] not in cached_data[fiat]: formatted_msg = self._format_currency_data( data, # eth_price, fiat, False)[0] cached_data[fiat][data['id']] = formatted_msg else: formatted_msg = cached_data[fiat][data['id']] else: formatted_msg = self._format_currency_data( data, # eth_price, fiat, False)[0] if fiat not in cached_data: cached_data[fiat] = {} if data['id'] not in cached_data[fiat]: cached_data[fiat][data['id']] = formatted_msg if len(result_msg) + len(formatted_msg) < 2000: result_msg += "{}\n".format(formatted_msg) else: formatted_data.append(result_msg) result_msg = "{}\n".format(formatted_msg) formatted_data.append(result_msg) return formatted_data, cached_data except CurrencyException as e: raise except FiatException as e: raise except Exception as e: raise CoinMarketException(e) def get_converted_coin_amt(self, market_list, currency1, currency2, currency_amt): """ Converts coin to coin based on btc price """ try: price_btc1 = float(market_list[currency1]['price_btc']) price_btc2 = float(market_list[currency2]['price_btc']) btc_amt = float("{:.8f}".format(currency_amt * price_btc1)) converted_amt = "{:.8f}".format(btc_amt / price_btc2).rstrip('0') return converted_amt except Exception as e: print("Failed to convert coin. See error.log.") logger.error("Exception: {}".format(str(e)))
def getCoinMarket(): coinmarketcap = Market() while True: print coinmarketcap.stats() print coinmarketcap.ticker(limit=4, convert='EUR') time.sleep(1) # Delays for 5 seconds. You can also use a float value.
# author: Christian Urcuqui # Date: 22 october 2018 # this code allows us to use APIs from different sources in order to know the value of the different crypto monies import requests from coinmarketcap import Market coinmarketcap = Market() print(coinmarketcap.stats()) print(coinmarketcap.ticker("steem"))