def get_action(self, bot, update, args):
base_cur = "USD"
fiat_symbol = "$"
if args:
base_cur = args[0].upper()
if base_cur == "EUR":
fiat_symbol = "€"
if RateLimit.limit_reached(update):
return
try:
market = CoinGecko().get_coins_markets(
base_cur.lower(),
per_page=30,
page=1,
order="market_cap_desc",
sparkline=False,
price_change_percentage=False)
except Exception as e:
return self.handle_error(e, update)
msg = str()
if market:
for i in range(30):
rank = market[i]['market_cap_rank']
symbol = market[i]['symbol'].upper()
name = market[i]['name']
price = market[i]['current_price']
price = utl.format(price, decimals=4, symbol=base_cur)
if base_cur == "EUR":
price = f"{price} {fiat_symbol}"
mcap = f"{utl.format(market[i]['market_cap'])}{fiat_symbol}"
vol = f"{utl.format(market[i]['total_volume'])}{fiat_symbol}"
elif base_cur == "USD":
price = f"{fiat_symbol}{price}"
mcap = f"{fiat_symbol}{utl.format(market[i]['market_cap'])}"
vol = f"{fiat_symbol}{utl.format(market[i]['total_volume'])}"
else:
price = f"{price}"
mcap = f"{utl.format(market[i]['market_cap'])}"
vol = f"{utl.format(market[i]['total_volume'])}"
msg += f"{rank}. *{symbol}* ({name}) - {price}\n" \
f"` M.Cap.: {mcap}`\n" \
f"` Volume: {vol}`\n"
if msg:
msg = f"*Top 30 Coins by Market Cap in {base_cur}*\n\n {msg}"
else:
msg = f"{emo.ERROR} Can't retrieve toplist"
update.message.reply_text(text=msg, parse_mode=ParseMode.MARKDOWN)
def get_action(self, bot, update, args):
if not args:
update.message.reply_text(
text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
if RateLimit.limit_reached(update):
return
vs_cur = "usd"
if "-" in args[0]:
pair = args[0].split("-", 1)
vs_cur = pair[1].lower()
coin = pair[0].upper()
else:
coin = args[0].upper()
data = None
try:
response = APICache.get_cg_coins_list()
except Exception as e:
return self.handle_error(e, update)
# Get coin ID and data
for entry in response:
if entry["symbol"].upper() == coin:
try:
data = CoinGecko().get_coin_by_id(entry["id"])
except Exception as e:
return self.handle_error(e, update)
break
if not data:
update.message.reply_text(
text=f"{emo.INFO} No data for *{coin}*",
parse_mode=ParseMode.MARKDOWN)
return
name = data["name"]
symbol = data["symbol"].upper()
if data["market_data"]["price_change_percentage_1h_in_currency"]:
c_1h = data["market_data"]["price_change_percentage_1h_in_currency"][vs_cur]
c1h = utl.format(float(c_1h), decimals=2, force_length=True)
h1 = "{:>10}".format(f"{c1h}%")
else:
h1 = "{:>10}".format("N/A")
if data["market_data"]["price_change_percentage_24h_in_currency"]:
c_1d = data["market_data"]["price_change_percentage_24h_in_currency"][vs_cur]
c1d = utl.format(float(c_1d), decimals=2, force_length=True)
d1 = "{:>10}".format(f"{c1d}%")
else:
d1 = "{:>10}".format("N/A")
if data["market_data"]["price_change_percentage_7d_in_currency"]:
c_1w = data["market_data"]["price_change_percentage_7d_in_currency"][vs_cur]
c1w = utl.format(float(c_1w), decimals=2, force_length=True)
w1 = "{:>10}".format(f"{c1w}%")
else:
w1 = "{:>10}".format("N/A")
if data["market_data"]["price_change_percentage_30d_in_currency"]:
c_1m = data["market_data"]["price_change_percentage_30d_in_currency"][vs_cur]
c1m = utl.format(float(c_1m), decimals=2, force_length=True)
m1 = "{:>10}".format(f"{c1m}%")
else:
m1 = "{:>10}".format("N/A")
if data["market_data"]["price_change_percentage_1y_in_currency"]:
c_1y = data["market_data"]["price_change_percentage_1y_in_currency"]["usd"]
c1y = utl.format(float(c_1y), decimals=2, force_length=True)
y1 = "{:>10}".format(f"{c1y}%")
else:
y1 = "{:>10}".format("N/A")
update.message.reply_text(
text=f"`"
f"{name} ({symbol}) in {vs_cur.upper()}\n\n"
f"Hour {h1}\n"
f"Day {d1}\n"
f"Week {w1}\n"
f"Month {m1}\n"
f"Year {y1}\n\n"
f"`",
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True)
def get_action(self, bot, update, args):
# TODO: Do this in every plugin
keywords = utl.get_kw(args)
arg_list = utl.del_kw(args)
# TODO: Do this in most other plugins
if not arg_list:
if not keywords.get(Keyword.INLINE):
update.message.reply_text(text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
vs_cur = str()
if "-" in arg_list[0]:
pair = arg_list[0].split("-", 1)
vs_cur = pair[1].upper()
coin = pair[0].upper()
else:
coin = arg_list[0].upper()
exchange = str()
if len(arg_list) > 1:
exchange = arg_list[1]
try:
response = APICache.get_cg_coins_list()
except Exception as e:
return self.handle_error(e, update)
coin_id = str()
coin_name = str()
for entry in response:
if entry["symbol"].upper() == coin:
coin_id = entry["id"]
coin_name = entry["name"]
break
if RateLimit.limit_reached(update):
return
cg = CoinGecko()
msg = str()
if exchange:
try:
result = cg.get_coin_by_id(coin_id)
except Exception as e:
return self.handle_error(e, update)
if result:
vs_list = list()
if vs_cur:
vs_list = vs_cur.split(",")
for ticker_len in result["tickers"]:
if ticker_len["market"]["name"].upper() == exchange.upper(
):
if ticker_len["base"] != coin:
base_coin = ticker_len["base"]
else:
base_coin = ticker_len["target"]
if vs_list:
if base_coin in vs_list:
price = utl.format(ticker_len["last"],
force_length=True)
msg += f"`{base_coin}: {price}`\n"
else:
price = utl.format(ticker_len["last"],
force_length=True)
msg += f"`{base_coin}: {price}`\n"
else:
if not vs_cur:
if coin == "BTC":
vs_cur = "ETH,USD,EUR"
elif coin == "ETH":
vs_cur = "BTC,USD,EUR"
else:
vs_cur = "BTC,ETH,USD,EUR"
try:
result = cg.get_simple_price(coin_id, vs_cur)
except Exception as e:
return self.handle_error(e, update)
if result:
for symbol, price in next(iter(result.values())).items():
if symbol in utl.get_fiat_list():
if decimal.Decimal(
str(price)).as_tuple().exponent > -3:
price = utl.format(price,
decimals=2,
force_length=True)
else:
price = utl.format(price, force_length=True)
else:
price = utl.format(price, force_length=True)
msg += f"`{symbol.upper()}: {price}`\n"
if msg:
if exchange:
ticker_len = 0
for line in msg.split("\n"):
length = len(line[:line.find(":")])
if ticker_len < length:
ticker_len = length
message = str()
for line in msg.split("\n"):
if line:
lst = line.split(" ")
index = ticker_len + 2 + len(lst[1]) - len(lst[0])
price = "{1:>{0}}".format(index, lst[1])
message += f"{lst[0]}{price}\n"
msg = f"`{coin} ({coin_name}) on {exchange.capitalize()}`\n\n" + message
else:
msg = f"`{coin} ({coin_name})`\n\n" + msg
# Add link to source of data (CoinGecko)
msg += f"\n[Details on CoinGecko]({self.CG_URL}{coin_id})"
else:
msg = f"{emo.ERROR} Can't retrieve data for *{coin}*"
if keywords.get(Keyword.INLINE):
return msg
self.send_msg(msg, update, keywords)
def get_action(self, bot, update, args):
if not args:
update.message.reply_text(text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
msg = str()
top = str()
coin = str()
vs_cur = "usd"
if args[0].lower().startswith("top="):
top = args[0][4:]
if not top.isnumeric():
update.message.reply_text(
text=f"{emo.ERROR} Value of `top` has to be a number",
parse_mode=ParseMode.MARKDOWN)
return
if int(top) > 100:
update.message.reply_text(
text=f"{emo.ERROR} Max value for `top` is `100`",
parse_mode=ParseMode.MARKDOWN)
return
else:
if "-" in args[0]:
pair = args[0].split("-", 1)
vs_cur = pair[0].lower()
coin = pair[1].lower()
else:
coin = args[0].lower()
if RateLimit.limit_reached(update):
return
# ---------- TOP VOLUME ----------
if top:
try:
data = CoinGecko().get_coins_markets(vs_cur,
per_page=top,
page=1,
order="volume_desc",
sparkline=False)
except Exception as e:
return self.handle_error(e, update)
count = 0
for entry in data:
count += 1
name = entry["name"]
symbol = entry["symbol"].upper()
vol = utl.format(entry["total_volume"])
msg += f"#{count} {name} ({symbol})\n" \
f"{vol} {vs_cur.upper()}\n\n"
msg = f"Top {top} by Total Volume\n\n{msg}"
# ---------- TOTAL VOLUME ----------
else:
data = None
try:
response = APICache.get_cg_coins_list()
except Exception as e:
return self.handle_error(e, update)
# Get coin ID and data
for entry in response:
if entry["symbol"] == coin:
try:
data = CoinGecko().get_coins_markets(
vs_cur, ids=entry["id"], order="volume_desc")
except Exception as e:
return self.handle_error(e, update)
break
if not data:
update.message.reply_text(
text=f"{emo.ERROR} No data for *{coin}*",
parse_mode=ParseMode.MARKDOWN)
return
name = data[0]["name"]
vol = utl.format(data[0]["total_volume"])
msg = f"{name} ({coin.upper()})\n\n" \
f"Total Volume:\n" \
f"{vol} {vs_cur.upper()}"
if not msg:
msg = f"{emo.ERROR} Can't retrieve data for *{coin.upper()}*"
update.message.reply_text(text=f"`{msg}`",
parse_mode=ParseMode.MARKDOWN)
def get_action(self, bot, update, args):
keywords = utl.get_kw(args)
arg_list = utl.del_kw(args)
if not arg_list:
if not keywords.get(Keyword.INLINE):
update.message.reply_text(text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
if RateLimit.limit_reached(update):
return
coin = arg_list[0].upper()
data = None
cgid = None
try:
response = APICache.get_cg_coins_list()
except Exception as e:
return self.handle_error(e, update)
# Get coin ID and data
for entry in response:
if entry["symbol"].upper() == coin:
try:
data = CoinGecko().get_coin_by_id(entry["id"])
except Exception as e:
return self.handle_error(e, update)
cgid = entry["id"]
break
if not data:
update.message.reply_text(text=f"{emo.ERROR} No data for *{coin}*",
parse_mode=ParseMode.MARKDOWN)
return
name = data["name"]
symbol = data["symbol"].upper()
rank_mc = data["market_cap_rank"]
rank_cg = data["coingecko_rank"]
cs = int(float(data['market_data']['circulating_supply']))
sup_c = f"{utl.format(cs)} {symbol}"
if data["market_data"]["total_supply"]:
ts = int(float(data["market_data"]["total_supply"]))
sup_t = f"{utl.format(ts)} {symbol}"
else:
sup_t = "N/A"
usd = data["market_data"]["current_price"]["usd"]
eur = data["market_data"]["current_price"]["eur"]
btc = data["market_data"]["current_price"]["btc"]
eth = data["market_data"]["current_price"]["eth"]
p_usd = utl.format(usd, force_length=True)
p_eur = utl.format(eur, force_length=True, template=p_usd)
p_btc = utl.format(btc, force_length=True, template=p_usd)
p_eth = utl.format(eth, force_length=True, template=p_usd)
p_usd = "{:>12}".format(p_usd)
p_eur = "{:>12}".format(p_eur)
p_btc = "{:>12}".format(p_btc)
p_eth = "{:>12}".format(p_eth)
# Do not display BTC or ETH price if coin is BTC or ETH
btc_str = "" if coin == "BTC" else f"BTC {p_btc}\n"
eth_str = "" if coin == "ETH" else f"ETH {p_eth}\n"
v_24h = utl.format(
int(float(data["market_data"]["total_volume"]["usd"])))
m_cap = utl.format(int(float(
data["market_data"]["market_cap"]["usd"])))
if data["market_data"]["price_change_percentage_1h_in_currency"]:
c_1h = data["market_data"][
"price_change_percentage_1h_in_currency"]["usd"]
c1h = utl.format(float(c_1h), decimals=2, force_length=True)
h1 = "{:>10}".format(f"{c1h}%")
else:
h1 = "{:>10}".format("N/A")
if data["market_data"]["price_change_percentage_24h_in_currency"]:
c_1d = data["market_data"][
"price_change_percentage_24h_in_currency"]["usd"]
c1d = utl.format(float(c_1d), decimals=2, force_length=True)
d1 = "{:>10}".format(f"{c1d}%")
else:
d1 = "{:>10}".format("N/A")
if data["market_data"]["price_change_percentage_7d_in_currency"]:
c_1w = data["market_data"][
"price_change_percentage_7d_in_currency"]["usd"]
c1w = utl.format(float(c_1w), decimals=2, force_length=True)
w1 = "{:>10}".format(f"{c1w}%")
else:
w1 = "{:>10}".format("N/A")
if data["market_data"]["price_change_percentage_30d_in_currency"]:
c_1m = data["market_data"][
"price_change_percentage_30d_in_currency"]["usd"]
c1m = utl.format(float(c_1m), decimals=2, force_length=True)
m1 = "{:>10}".format(f"{c1m}%")
else:
m1 = "{:>10}".format("N/A")
if data["market_data"]["price_change_percentage_1y_in_currency"]:
c_1y = data["market_data"][
"price_change_percentage_1y_in_currency"]["usd"]
c1y = utl.format(float(c_1y), decimals=2, force_length=True)
y1 = "{:>10}".format(f"{c1y}%")
else:
y1 = "{:>10}".format("N/A")
msg = f"`" \
f"{name} ({symbol})\n\n" \
f"USD {p_usd}\n" \
f"EUR {p_eur}\n" \
f"{btc_str}" \
f"{eth_str}\n" \
f"Hour {h1}\n" \
f"Day {d1}\n" \
f"Week {w1}\n" \
f"Month {m1}\n" \
f"Year {y1}\n\n" \
f"Market Cap Rank: {rank_mc}\n" \
f"Coin Gecko Rank: {rank_cg}\n\n" \
f"Volume 24h: {v_24h} USD\n" \
f"Market Cap: {m_cap} USD\n" \
f"Circ. Supp: {sup_c}\n" \
f"Total Supp: {sup_t}\n\n" \
f"`" \
f"Stats on [CoinGecko](https://www.coingecko.com/en/coins/{cgid}) & " \
f"[Coinlib](https://coinlib.io/coin/{coin}/{coin})"
if keywords.get(Keyword.INLINE):
return msg
self.send_msg(msg, update, keywords)
def get_action(self, bot, update, args):
if args:
t = args[0].lower()
if not t == "hour" and not t == "day":
update.message.reply_text(
text=
f"{emo.ERROR} First argument has to be `day` or `hour`",
parse_mode=ParseMode.MARKDOWN)
return
if len(args) > 1:
entries = args[1]
if not entries.isnumeric():
update.message.reply_text(
text=f"{emo.ERROR} Second argument (# of positions "
f"to display) has to be a number",
parse_mode=ParseMode.MARKDOWN)
return
if len(args) > 2:
entries = args[2]
if not entries.isnumeric():
update.message.reply_text(
text=f"{emo.ERROR} Third argument (min. volume) "
f"has to be a number",
parse_mode=ParseMode.MARKDOWN)
return
if RateLimit.limit_reached(update):
return
period = CoinData.HOUR
volume = None
entries = 10
if args:
# Period
if args[0].lower() == "hour":
period = CoinData.HOUR
elif args[0].lower() == "day":
period = CoinData.DAY
else:
period = CoinData.HOUR
# Entries
if len(args) > 1 and args[1].isnumeric():
entries = int(args[1])
# Volume
if len(args) > 2 and args[2].isnumeric():
volume = int(args[2])
try:
best = CoinData().get_movers(CoinData.WORST,
period=period,
entries=entries,
volume=volume)
except Exception as e:
return self.handle_error(e, update)
if not best:
update.message.reply_text(
text=f"{emo.ERROR} No matching data found",
parse_mode=ParseMode.MARKDOWN)
return
msg = str()
for coin in best:
name = coin["Name"]
symbol = coin["Symbol"]
desc = f"{name} ({symbol})"
if len(desc) > self.DESC_LEN:
desc = f"{desc[:self.DESC_LEN-3]}..."
if period == CoinData.HOUR:
change = coin["Change_1h"]
else:
change = coin["Change_24h"]
change = utl.format(change, decimals=2, force_length=True)
change = "{1:>{0}}".format(self.DESC_LEN + 9 - len(desc), change)
msg += f"`{desc}{change}%`\n"
vol = str()
if volume:
vol = f" (vol > {utl.format(volume)})"
update.message.reply_text(
text=f"`Worst movers 1{period.lower()[:1]}{vol}\n\n`" + msg,
parse_mode=ParseMode.MARKDOWN)
def get_action(self, bot, update, args):
if not args:
update.message.reply_text(text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
if RateLimit.limit_reached(update):
return
coin = args[0].upper()
msg = str()
try:
response = APICache.get_cg_coins_list()
except Exception as e:
self.handle_error(e, update)
for entry in response:
if entry["symbol"].lower() == coin.lower():
try:
data = CoinGecko().get_coin_by_id(entry["id"])
except Exception as e:
self.handle_error(e, update)
if "ico_data" not in data:
break
ico_start = data["ico_data"]["ico_start_date"][:10]
ico_end = data["ico_data"]["ico_end_date"][:10]
raised = data["ico_data"]["total_raised"]
raised_cur = data["ico_data"]["total_raised_currency"]
pre_sale_c = data["ico_data"]["quote_pre_sale_currency"]
pre_sale_a = data["ico_data"]["base_pre_sale_amount"]
pre_sale_p = data["ico_data"]["quote_pre_sale_amount"]
pub_sale_c = data["ico_data"]["quote_public_sale_currency"]
pub_sale_a = data["ico_data"]["base_public_sale_amount"]
pub_sale_p = data["ico_data"]["quote_public_sale_amount"]
kyc_req = data["ico_data"]["kyc_required"]
raised = utl.format(raised) if raised is not None else raised
if pre_sale_a:
pre_sale_a = utl.format(pre_sale_a, symbol=coin)
if pre_sale_p:
pre_sale_p = utl.format(pre_sale_p, symbol=pre_sale_c)
if pub_sale_a:
pub_sale_a = utl.format(pub_sale_a, symbol=coin)
if pub_sale_p:
pub_sale_p = utl.format(pub_sale_p, symbol=pub_sale_c)
if pre_sale_a:
pre_sale_str = f"{pre_sale_a} {coin} for {pre_sale_p} {pre_sale_c}\n"
else:
pre_sale_str = "None\n"
if pub_sale_a:
pub_sale_str = f"{pub_sale_a} {coin} for {pub_sale_p} {pub_sale_c}\n"
else:
pub_sale_str = "None\n"
msg = f"`" \
f"Start: {ico_start}\n" \
f"End: {ico_end}\n" \
f"Raised: {raised} {raised_cur}\n" \
f"Pre-Sale: {pre_sale_str}" \
f"Pub-Sale: {pub_sale_str}" \
f"KYC: {'Yes' if kyc_req == True else 'No'}" \
f"`"
break
if msg:
msg = f"`ICO data for {coin}`\n\n" + msg
else:
msg = f"{emo.INFO} No ICO data for *{coin}*"
update.message.reply_text(text=msg, parse_mode=ParseMode.MARKDOWN)
def get_action(self, bot, update, args):
if not args:
update.message.reply_text(text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
if RateLimit.limit_reached(update):
return
coin = args[0].upper()
try:
data = TokenStats().get_roi_for_symbol(coin)
except Exception as e:
self.handle_error(e, update)
if not data:
update.message.reply_text(
text=f"{emo.INFO} No data found for {coin}",
parse_mode=ParseMode.MARKDOWN)
return
msg = str(f"`Return on Investment for {coin}`\n\n")
roi_usd_x = utl.format(data["roix_usd"],
decimals=2,
force_length=True,
on_none="-")
roi_usd_x = "{:>10}".format(roi_usd_x)
roi_btc_x = utl.format(data["roix_btc"],
decimals=2,
force_length=True,
on_none="-")
roi_btc_x = "{:>10}".format(roi_btc_x)
roi_eth_x = utl.format(data["roix_eth"],
decimals=2,
force_length=True,
on_none="-")
roi_eth_x = "{:>10}".format(roi_eth_x)
# If all values are the same then this means
# that there was no ICO and thus no ROI available
if roi_usd_x == roi_btc_x == roi_eth_x:
update.message.reply_text(
text=f"{emo.ERROR} No ROI data for {coin}",
parse_mode=ParseMode.MARKDOWN)
return
if data["roix_usd"]:
msg += f"`ROI USD: {roi_usd_x}x`\n"
else:
msg += f"`ROI USD: {roi_usd_x}`\n"
if data["roix_btc"]:
msg += f"`ROI BTC: {roi_btc_x}x`\n"
else:
msg += f"`ROI BTC: {roi_btc_x}`\n"
if data["roix_eth"]:
msg += f"`ROI ETH: {roi_eth_x}x`\n\n"
else:
msg += f"`ROI ETH: {roi_eth_x}`\n\n"
pre_p_usd = data["usd_price_at_presale"]
pre_p_usd_f = utl.format(pre_p_usd,
decimals=2,
force_length=True,
on_zero='-')
pre_p_btc = data["btc_price_at_presale"]
pre_p_btc_f = utl.format(pre_p_btc, decimals=8, on_zero='-')
pre_p_eth = data["eth_price_at_presale"]
pre_p_eth_f = utl.format(pre_p_eth, decimals=8, on_zero='-')
msg += f"`Presale Price USD: {pre_p_usd_f}`\n"
msg += f"`Presale Price BTC: {pre_p_btc_f}`\n"
msg += f"`Presale Price ETH: {pre_p_eth_f}`\n\n"
lnc_p_usd = data["usd_price_at_launch"]
lnc_p_usd_f = utl.format(lnc_p_usd,
decimals=2,
force_length=True,
on_zero='-')
lnc_p_btc = data["btc_price_at_launch"]
lnc_p_btc_f = utl.format(lnc_p_btc, decimals=8, on_zero='-')
lnc_p_eth = data["eth_price_at_launch"]
lnc_p_eth_f = utl.format(lnc_p_eth, decimals=8, on_zero='-')
msg += f"`Launch Price USD: {lnc_p_usd_f}`\n"
msg += f"`Launch Price BTC: {lnc_p_btc_f}`\n"
msg += f"`Launch Price ETH: {lnc_p_eth_f}`\n\n"
cur_p_usd = data["current_usd_price"]
cur_p_usd_f = utl.format(cur_p_usd,
decimals=2,
force_length=True,
on_zero='-')
cur_p_btc = data["current_btc_price"]
cur_p_btc_f = utl.format(cur_p_btc, decimals=8, on_zero='-')
cur_p_eth = data["current_eth_price"]
cur_p_eth_f = utl.format(cur_p_eth, decimals=8, on_zero='-')
msg += f"`Current Price USD: {cur_p_usd_f}`\n"
msg += f"`Current Price BTC: {cur_p_btc_f}`\n"
msg += f"`Current Price ETH: {cur_p_eth_f}`"
update.message.reply_text(text=msg,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True)
def get_action(self, bot, update, args):
keywords = utl.get_kw(args)
arg_list = utl.del_kw(args)
if not arg_list:
if not keywords.get(Keyword.INLINE):
update.message.reply_text(
text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
if RateLimit.limit_reached(update):
return
vs_cur = "usd"
if "-" in arg_list[0]:
pair = arg_list[0].split("-", 1)
vs_cur = pair[1].lower()
coin = pair[0].upper()
else:
coin = arg_list[0].upper()
ath_date = str()
ath_price = str()
cur_price = str()
ath_change = str()
# Get coin ID
try:
response = APICache.get_cg_coins_list()
except Exception as e:
return self.handle_error(e, update)
for entry in response:
if entry["symbol"].lower() == coin.lower():
try:
coin_info = CoinGecko().get_coin_by_id(entry["id"])
except Exception as e:
return self.handle_error(e, update)
cur_price = coin_info["market_data"]["current_price"]
ath_price = coin_info["market_data"]["ath"]
ath_date = coin_info["market_data"]["ath_date"]
ath_change = coin_info["market_data"]["ath_change_percentage"]
break
msg = str()
for c in vs_cur.split(","):
if c in ath_price:
ath_p = format(ath_price[c])
cur_p = format(cur_price[c], template=ath_p)
change = format(ath_change[c], decimals=2)
date_time = ath_date[c]
date_ath = date_time[:10]
date_list = date_ath.split("-")
y = int(date_list[0])
m = int(date_list[1])
d = int(date_list[2])
ath = date(y, m, d)
now = datetime.date.today()
ath_p_str = f"Price ATH: {ath_p} {c.upper()}\n"
cur_p_str = f"Price NOW: {cur_p.rjust(len(ath_p))} {c.upper()}\n"
msg += f"`" \
f"{date_ath} ({(now - ath).days} days ago)\n" \
f"{ath_p_str}" \
f"{cur_p_str}" \
f"Change: {change}%\n\n" \
f"`"
if msg:
msg = f"`All-Time High for {coin}`\n\n {msg}"
else:
msg = f"{emo.ERROR} Can't retrieve data for *{coin}*"
if keywords.get(Keyword.INLINE):
return msg
self.send_msg(msg, update, keywords)
def get_action(self, bot, update, args):
vs_cur = str()
if not args:
if update.message:
update.message.reply_text(text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
if "-" in args[0]:
pair = args[0].split("-", 1)
vs_cur = pair[0].upper()
coin = pair[1].upper()
else:
coin = args[0].upper()
exchange = str()
if len(args) > 1:
exchange = args[1]
try:
response = APICache.get_cg_coins_list()
except Exception as e:
self.handle_error(e, update)
coin_id = str()
for entry in response:
if entry["symbol"].upper() == coin:
coin_id = entry["id"]
break
if RateLimit.limit_reached(update):
return
cg = CoinGecko()
msg = str()
if exchange:
try:
result = cg.get_coin_by_id(coin_id)
except Exception as e:
self.handle_error(e, update)
if result:
vs_list = list()
if vs_cur:
vs_list = vs_cur.split(",")
for ticker in result["tickers"]:
if ticker["market"]["name"].upper() == exchange.upper():
base_coin = ticker["target"]
if vs_list:
if base_coin in vs_list:
price = utl.format(ticker["last"],
force_length=True)
msg += f"`{base_coin}: {price}`\n"
else:
price = utl.format(ticker["last"],
force_length=True)
msg += f"`{base_coin}: {price}`\n"
else:
if not vs_cur:
if coin == "BTC":
vs_cur = "ETH,USD,EUR"
elif coin == "ETH":
vs_cur = "BTC,USD,EUR"
else:
vs_cur = "BTC,ETH,USD,EUR"
try:
result = cg.get_simple_price(coin_id, vs_cur)
except Exception as e:
self.handle_error(e, update)
if result:
for symbol, price in next(iter(result.values())).items():
if symbol in utl.get_fiat_list():
if decimal.Decimal(
str(price)).as_tuple().exponent > -3:
price = utl.format(price,
decimals=2,
force_length=True)
else:
price = utl.format(price, force_length=True)
else:
price = utl.format(price, force_length=True)
msg += f"`{symbol.upper()}: {price}`\n"
if msg:
if exchange:
msg = f"`Price of {coin} on {exchange.capitalize()}`\n\n" + msg
else:
msg = f"`Price of {coin}`\n\n" + msg
else:
msg = f"{emo.ERROR} Can't retrieve data for *{coin}*"
if update.message:
update.message.reply_text(text=msg, parse_mode=ParseMode.MARKDOWN)
else:
return msg
def get_action(self, bot, update, args):
if not args:
update.message.reply_text(text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
sub_cmd = args[0]
if not sub_cmd:
update.message.reply_text(text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
if RateLimit.limit_reached(update):
return
msg = str()
try:
res = CoinGecko().get_global()
except Exception as e:
return self.handle_error(e, update)
# ---------- Total Market Capital ----------
if sub_cmd.lower() == "mcap":
m_cap_usd = utl.format(res["total_market_cap"]["usd"])
m_cap_eur = utl.format(res["total_market_cap"]["eur"])
msg = f"`Total Market Capital`\n" \
f"`USD: {m_cap_usd}`\n" \
f"`EUR: {m_cap_eur}`"
# ---------- Total Volume ----------
elif sub_cmd.lower() == "vol":
vol_usd = utl.format(res["total_volume"]["usd"])
vol_eur = utl.format(res["total_volume"]["eur"])
msg = f"`Total Volume (24h)`\n" \
f"`USD: {vol_usd}`\n" \
f"`EUR: {vol_eur}`"
# ---------- Dominance ----------
elif sub_cmd.lower() == "dom":
m_cap_per = res["market_cap_percentage"]
labels = list()
values = list()
msg = "`Dominance (Market Capital)`\n"
for key in sorted(m_cap_per, key=m_cap_per.get, reverse=True):
labels.append(key.upper())
values.append(m_cap_per[key])
value = utl.format(m_cap_per[key],
decimals=2,
force_length=True)
tst = "{:>13}".format(f"{value}%")
tst = key.upper() + tst[len(key):]
msg += f"`{tst}`\n"
labels.append("[Other]")
values.append(100 - sum(values))
layout = go.Layout(paper_bgcolor='rgb(233,233,233)',
plot_bgcolor='rgb(233,233,233)',
autosize=True,
margin=go.layout.Margin(l=20,
r=20,
b=20,
t=20,
pad=4))
try:
trace = go.Pie(labels=labels, values=values)
fig = go.Figure(data=[trace], layout=layout)
except Exception as e:
return self.handle_error(e, update)
update.message.reply_photo(photo=io.BufferedReader(
BytesIO(pio.to_image(fig, format="jpeg"))),
caption=msg,
parse_mode=ParseMode.MARKDOWN)
return
if not msg:
msg = f"{emo.ERROR} Can't retrieve global data*"
update.message.reply_text(text=msg, parse_mode=ParseMode.MARKDOWN)
def get_action(self, bot, update, args):
if not args:
update.message.reply_text(text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
if RateLimit.limit_reached(update):
return
coin = args[0].upper()
coin_info = None
volume = False
if len(args) > 1:
if args[1].lower().startswith("vol"):
volume = True
try:
response = APICache.get_cg_coins_list()
except Exception as e:
return self.handle_error(e, update)
# Get coin ID and data
for entry in response:
if entry["symbol"].upper() == coin:
try:
coin_info = CoinGecko().get_coin_by_id(entry["id"])
except Exception as e:
return self.handle_error(e, update)
break
if not coin_info or not coin_info["tickers"]:
update.message.reply_text(text=f"{emo.ERROR} No data for *{coin}*",
parse_mode=ParseMode.MARKDOWN)
return
# Sort markets by volume
if volume:
data = sorted(coin_info["tickers"],
key=lambda k: float(k["volume"]),
reverse=True)
count = len(data)
if count > 10:
count = 10
msg = str()
for i in range(count):
vs_cur = data[i]["target"]
exchange = data[i]["market"]["name"]
vol_usd = data[i]["converted_volume"]["usd"]
vol_usd = utl.format(vol_usd, decimals=2, force_length=True)
msg += f"{exchange} - {vs_cur}\nVolume: {vol_usd} USD\n\n"
update.message.reply_text(text=f"`Exchanges that trade {coin}`\n"
f"`Top 10 sorted by volume\n\n{msg}`",
parse_mode=ParseMode.MARKDOWN)
else:
exchanges = set()
for ticker in coin_info["tickers"]:
exchanges.add(ticker['market']['name'])
exchanges = "\n".join(sorted(exchanges))
update.message.reply_text(
text=f"`Exchanges that trade {coin}`\n\n`{exchanges}`",
parse_mode=ParseMode.MARKDOWN)
def get_action(self, bot, update, args):
if not args:
update.message.reply_text(text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
if RateLimit.limit_reached(update):
return
coin = args[0].upper()
msg = str()
try:
response = APICache.get_cg_coins_list()
except Exception as e:
return self.handle_error(e, update)
for entry in response:
if entry["symbol"].lower() == coin.lower():
try:
data = CoinGecko().get_coin_by_id(entry["id"])
except Exception as e:
return self.handle_error(e, update)
home_lst = list(filter(None, data["links"]["homepage"]))
block_lst = list(filter(None,
data["links"]["blockchain_site"]))
annou_lst = list(
filter(None, data["links"]["announcement_url"]))
chat_lst = list(filter(None, data["links"]["chat_url"]))
forum_lst = list(
filter(None, data["links"]["official_forum_url"]))
twitter = data["links"]["twitter_screen_name"]
facebook = data["links"]["facebook_username"]
btctalk = data["links"]["bitcointalk_thread_identifier"]
telegram = data["links"]["telegram_channel_identifier"]
reddit = data["links"]["subreddit_url"]
fb_likes = data["community_data"]["facebook_likes"]
tw_follow = data["community_data"]["twitter_followers"]
rd_subsc = data["community_data"]["reddit_subscribers"]
tg_usr_cnt = data["community_data"][
"telegram_channel_user_count"]
msg = f"`Social data for {data['name']} ({coin})`\n\n"
if home_lst:
url = utl.esc_md(utl.url(home_lst))
msg += f"`Homepage:`\n{url}\n"
if block_lst:
url = utl.esc_md(utl.url(block_lst))
msg += f"`Block Explorer:`\n{url}\n"
if annou_lst:
url = utl.esc_md(utl.url(annou_lst))
msg += f"`Announcements:`\n{url}\n"
if chat_lst:
url = utl.esc_md(utl.url(chat_lst))
msg += f"`Chat:`\n{url}\n"
if forum_lst:
url = utl.esc_md(utl.url(forum_lst))
msg += f"`Forum:`\n{url}\n"
if twitter:
tw_follow = utl.format(tw_follow)
url = utl.esc_md(f"{self.TW_URL}{twitter}")
msg += f"`Twitter ({tw_follow} Followers):`\n{url}\n"
if facebook:
fb_likes = utl.format(fb_likes)
url = utl.esc_md(f"{self.FB_URL}{facebook}")
msg += f"`Facebook ({fb_likes} Likes):`\n{url}\n"
if btctalk:
url = utl.esc_md(f"{self.BT_URL}{btctalk}")
msg += f"`BitcoinTalk:`\n{url}\n"
if telegram:
tg_usr_cnt = utl.format(tg_usr_cnt)
url = utl.esc_md(f"{self.TG_URL}{telegram}")
msg += f"`Telegram ({tg_usr_cnt} Users):`\n{url}\n"
if reddit:
rd_subsc = utl.format(rd_subsc)
url = utl.esc_md(f"{utl.url(reddit)}")
msg += f"`Reddit ({rd_subsc} Subscribers):`\n{url}\n"
break
if not msg:
update.message.reply_text(
text=f"{emo.ERROR} No data found for *{coin}*",
parse_mode=ParseMode.MARKDOWN)
return
update.message.reply_text(text=msg,
disable_web_page_preview=True,
parse_mode=ParseMode.MARKDOWN)
def get_action(self, bot, update, args):
if not args:
update.message.reply_text(text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
vs_cur = "btc,eth,usd,eur"
if "-" in args[0]:
pair = args[0].split("-", 1)
vs_cur = pair[0].lower()
coin = pair[1].upper()
else:
coin = args[0].upper()
if len(args) > 1 and utl.is_number(args[1]):
qty = args[1]
else:
update.message.reply_text(text=f"Usage:\n{self.get_usage()}",
parse_mode=ParseMode.MARKDOWN)
return
if RateLimit.limit_reached(update):
return
prices = dict()
try:
response = APICache.get_cg_coins_list()
except Exception as e:
return self.handle_error(e, update)
# Get coin ID
for entry in response:
if entry["symbol"].upper() == coin:
try:
data = CoinGecko().get_coin_by_id(entry["id"])
except Exception as e:
return self.handle_error(e, update)
prices = data["market_data"]["current_price"]
break
try:
qty_float = float(qty)
except Exception:
update.message.reply_text(
text=f"{emo.ERROR} Quantity '{qty}' not valid",
parse_mode=ParseMode.MARKDOWN)
return
msg = str()
for c in vs_cur.split(","):
if c in prices:
value = utl.format(prices[c] * qty_float)
msg += f"`{c.upper()}: {value}`\n"
if msg:
msg = f"`Value of {qty} {coin}`\n\n" + msg
else:
msg = f"{emo.ERROR} Can't retrieve data for *{coin}*"
update.message.reply_text(text=msg, parse_mode=ParseMode.MARKDOWN)
