def update_keltner_coins(self):
highest_price_history = utils.file_to_json(
'coin_highest_price_history.json')
for market in self.keltner_coins:
if market in self.bittrex_coins:
bittrex_coin = self.bittrex_coins[market]
cur_price = bittrex_coin['Last']
self.keltner_coins[market]['price_data_seconds'].append(
cur_price)
highest_price_history = self.update_highest_price(
market, highest_price_history, cur_price)
if self.ten_second_count > 5:
self.keltner_coins[market]['price_data_minutes'].append(
cur_price)
self.update_atr(market)
self.update_ema(market)
self.update_bands(market)
self.keltner_coins[market]['price_data_seconds'] =\
self.keltner_coins[market]['price_data_seconds'][-6:]
if len(self.keltner_coins[market]
['price_data_minutes']) == self.keltner_period:
self.keltner_coins[market]['price_data_minutes'].pop(0)
if self.ten_second_count > 5:
self.ten_second_count = 0
else:
self.ten_second_count += 1
utils.json_to_file(highest_price_history,
'coin_highest_price_history.json')
utils.json_to_file(self.keltner_coins, "keltner_coins.json")
def update_reddit_coins(self):
self.mentioned_words = {}
reddit_coins = utils.file_to_json('reddit_coins.json')
for submission in self.reddit_api.subreddit('CryptoCurrency').top(
'day'):
if submission not in reddit_coins['submissions']:
self.add_to_words_coins(submission.title, submission.score,
submission.created)
reddit_coins = self.find_mentions(submission.title,
reddit_coins,
str(submission),
submission.created,
submission.score)
for comment in submission.comments:
try:
reddit_coins = self.find_mentions(
comment.body, reddit_coins, str(comment),
comment.created, comment.score)
self.add_to_words_coins(comment.body, comment.score,
comment.created)
except:
pass
reddit_coins['submissions'].append(str(submission))
utils.json_to_file(reddit_coins, 'reddit_coins.json')
self.rank_by_mentions()
self.rank_by_upvotes()
self.rank_by_upvotes_and_sentiment()
def add_bittrex_coins_to_keltner_coins(self, coinmarketcap_coins):
self.keltner_coins = {}
self.coinmarketcap_coins = self.update_coinmarketcap_coins()
self.bittrex_coins = self.update_bittrex_coins(
self.coinmarketcap_coins)
for market in self.bittrex_coins:
if market.startswith('BTC'):
symbol = utils.get_second_market_coin(market)
if symbol in coinmarketcap_coins:
coin_rank = int(coinmarketcap_coins[symbol])
if coin_rank <= self.lowest_rank:
t = {}
t['market'] = market
t['price_data_seconds'] = []
t['price_data_minutes'] = []
t['tr_data'] = []
t['atr_data'] = []
t['ema_data'] = []
t['upper_band_data'] = []
t['middle_band_data'] = []
t['lower_band_data'] = []
self.keltner_coins[market] = t
utils.json_to_file(self.keltner_coins, "keltner_coins.json")
def keltner_buy_strat(self, total_bitcoin):
if len(self.keltner_coins['BTC-ETH']
['upper_band_data']) > self.keltner_period:
keltner_slots_open = self.keltner_slots - len(
self.held_coins) - len(self.pending_orders['Buying']) - len(
self.pending_orders['Selling'])
for coin in self.keltner_coins:
market = self.bittrex_coins[coin]['MarketName']
lower_band_data = self.keltner_coins[market]['lower_band_data']
if len(lower_band_data) == self.keltner_period:
coins_pending_buy = [
market for market in self.pending_orders['Buying']
]
coins_pending_sell = [
market for market in self.pending_orders['Selling']
]
if market not in self.held_coins and market not in coins_pending_buy and market not in coins_pending_sell:
cur_price = self.bittrex_coins[coin]['Last']
if self.upward_cross(market, 'lower_band_data'):
bitcoin_to_use = float(total_bitcoin /
(keltner_slots_open + .25))
amount = bitcoin_to_use / cur_price
percent_change_24h = utils.get_percent_change_24h(
coin)
utils.buy(self.api, market, amount, cur_price,
percent_change_24h, 0)
keltner_slots_open = self.total_slots - len(
self.held_coins) - len(
self.pending_orders['Buying']) - len(
self.pending_orders['Selling'])
def percent_sell_strat(self):
"""
If a coin drops more than 10% of its highest price then sell
"""
held_markets = [market for market in self.held_coins]
for coin_market in held_markets:
current_high = self.history_coins[coin_market]
coin_price = float(self.bittrex_coins[coin_market]['Last'])
"""
if cur_24h_change > highest_24h_change:
self.held_coins[coin_market]['highest_24h_change'] = cur_24h_change
highest_24h_change = cur_24h_change
utils.json_to_file(self.held_coins, "held_coins.json")
self.held_coins[coin_market]['sell_threshold'] = self.updated_threshold(coin_market, self.held_coins)
utils.json_to_file(self.held_coins, "held_coins.json")
"""
if coin_price < current_high * 0.97:
coin_to_sell = utils.get_second_market_coin(coin_market)
balance = self.api.get_balance(coin_to_sell)
if balance['success']:
amount = float(balance['result']['Available'])
if amount > 0:
utils.sell(self.api, amount, coin_market,
self.bittrex_coins)
else:
utils.print_and_write_to_logfile(
"Could not retrieve balance: " + balance['message'])
def __init__(self, api, total_slots):
self.api = api
self.total_slots = total_slots
self.bittrex_coins = utils.get_updated_bittrex_coins()
self.held_coins = utils.file_to_json("held_coins.json")
self.pending_orders = utils.file_to_json("pending_orders.json")
def percent_sell_strat(self):
ignored = utils.file_to_json("ignored_coins.json")
held_markets = [market for market in self.held_coins]
for coin_market in held_markets:
current_high = self.history_coins[coin_market]
coin_price = float(self.bittrex_coins[coin_market]['Last'])
percent_change_24h = utils.get_percent_change_24h(
self.bittrex_coins[coin_market])
if coin_price < current_high * 0.80 \
or percent_change_24h >= 110:
coin_to_sell = utils.get_second_market_coin(coin_market)
balance = self.api.get_balance(coin_to_sell)
if balance['success']:
amount = float(balance['result']['Available'])
if amount > 0:
utils.sell(self.api, amount, coin_market,
self.bittrex_coins)
ignored[coin_market] = 1
utils.json_to_file(ignored, "ignored_coins.json")
else:
utils.print_and_write_to_logfile(
"Could not retrieve balance: " + balance['message'])
def update_pending_orders(orders):
"""
Checks bitttrex's open orders and if a coin that's in
pending_orders is no longer in bittrex's pending orders
it has gone through, so we add it to our held coins.
:param orders:
:return:
"""
pending_orders = utils.file_to_json("pending_orders.json")
# Move processed buy orders from pending_orders into held_coins
processing_orders = [order['OrderUuid'] for order in orders]
buy_uuids_markets = [(pending_orders['Buying'][market]['uuid'], market)
for market in pending_orders['Buying']]
for buy_uuids_market in buy_uuids_markets:
buy_uuid = buy_uuids_market[0]
if buy_uuid not in processing_orders:
buy_market = buy_uuids_market[1]
pending_buy_order = pending_orders['Buying'][buy_market]
amount = str(pending_buy_order['amount'])
utils.print_and_write_to_logfile("Buy order: " + amount + " of " +
buy_market +
" Processed Successfully " +
"UUID: " + buy_uuid + " " +
utils.get_date_time())
move_to_from_held(buy_market, 'Buying')
# Add price to highest_price_history
highest_price_list = utils.file_to_json(
"coin_highest_price_history.json")
highest_price_list[buy_market] = pending_orders['Buying'][
buy_market]['price_bought']
utils.json_to_file(highest_price_list,
'coin_highest_price_history.json')
# Move processed sold orders from pending_orders into held_coins
sell_uuids_markets = [(pending_orders['Selling'][market]['uuid'], market)
for market in pending_orders['Selling']]
for sell_uuids_market in sell_uuids_markets:
if sell_uuids_market[0] not in processing_orders:
pending_sell_order = pending_orders['Selling'][
sell_uuids_market[1]]
amount = str(pending_sell_order['amount'])
utils.print_and_write_to_logfile("Sell order: " + amount + " of " +
" " + sell_uuids_market[1] +
" Processed Successfully " +
"UUID: " + sell_uuids_market[0] +
" " + utils.get_date_time())
move_to_from_held(sell_uuids_market[1], 'Selling')
def initialize_percent_strat():
utils.init_global_return()
buy_min_percent = 30
buy_max_percent = 1000
buy_desired_1h_change = 10
total_slots = 4
data_ticks_to_save = 180
return PS.PercentStrat(api, buy_min_percent, buy_max_percent,
buy_desired_1h_change, total_slots,
data_ticks_to_save)
def update_bittrex_coins(self, coinmarketcap_coins):
bittrex_data = utils.query_url(
"https://bittrex.com/api/v1.1/public/getmarketsummaries")['result']
coins = {}
for coin in bittrex_data:
symbol = utils.get_second_market_coin(coin['MarketName'])
if symbol in coinmarketcap_coins:
coin_rank = int(coinmarketcap_coins[symbol])
if coin_rank <= self.lowest_rank:
key = coin['MarketName']
coins[key] = coin
return coins
def reset_keltner_coins(self):
self.keltner_coins = utils.file_to_json("keltner_coins.json")
for coin in self.keltner_coins:
self.keltner_coins[coin]['price_data_minutes'] = []
self.keltner_coins[coin]['price_data_seconds'] = []
self.keltner_coins[coin]['tr_data'] = []
self.keltner_coins[coin]['atr_data'] = []
self.keltner_coins[coin]['ema_data'] = []
self.keltner_coins[coin]['upper_band_data'] = []
self.keltner_coins[coin]['middle_band_data'] = []
self.keltner_coins[coin]['lower_band_data'] = []
utils.json_to_file(self.keltner_coins, "keltner_coins.json")
def __init__(self, api, desired_gain, desired_low_point, total_slots):
self.api = api
self.desired_gain = desired_gain
self.desired_low_point = desired_low_point
self.total_slots = total_slots
self.count_until_reddit_strat = 0
self.bittrex_coins = utils.get_updated_bittrex_coins()
self.held_coins = utils.file_to_json("held_coins.json")
self.pending_orders = utils.file_to_json("pending_orders.json")
self.fill_low_bars()
def clean_orders(orders):
"""
Finds any order that has been attempting to buy
or sell for longer than the variable
time_until_cancel_processing_order_minutes
and attempt to cancel them on bittrex, and
also deletes them from pending_orders.json
:param orders:
:return void:
"""
pending_orders = utils.file_to_json("pending_orders.json")
for order in orders:
time_opened = order['Opened']
time_passed = utils.get_time_passed_minutes(time_opened)
uuid = order['OrderUuid']
market = ""
buying_or_selling = 'Buying' if order[
'OrderType'] == 'LIMIT_BUY' else 'Selling'
for pending_market in pending_orders[buying_or_selling]:
if pending_orders[buying_or_selling][pending_market][
'uuid'] == uuid:
market = pending_market
if time_passed > time_until_cancel_processing_order_minutes:
uuid = order['OrderUuid']
cancel_order = api.cancel(uuid)
if cancel_order['success']:
if market in pending_orders[buying_or_selling]:
del pending_orders[buying_or_selling][market]
utils.json_to_file(pending_orders, "pending_orders.json")
utils.print_and_write_to_logfile("Cancel Order of " +
str(order["Quantity"]) +
" " +
str(order['Exchange']) +
" Successful " +
utils.get_date_time())
else:
utils.print_and_write_to_logfile("Cancel Order of " +
str(order["Quantity"]) +
order['Exchange'] +
" Unsuccessful: " +
cancel_order['message'] +
" " + utils.get_date_time())
def store_top_10_data(self):
most_upvoted = self.coins_ranked_by_upvotes
# most_mentioned = self.coins_ranked_by_mentions
reddit_coins = utils.file_to_json('reddit_coins.json')
count = 10
out_string = ""
top_coins = {}
rank = 0
for pair in most_upvoted:
if count <= 0:
break
count -= 1
symbol = pair[0]
coin_data = reddit_coins[symbol]
out_string += "*********************** " + symbol + " ***********************" + "\n"
self.add_to_top_coins("BTC-" + symbol, top_coins, rank)
rank += 1
upvote_list = coin_data['upvotes']
text_list = coin_data['text']
time_list = coin_data['mentioned_times']
sorted_comments = self.sort_comments(upvote_list, text_list,
time_list)
for i in range(len(upvote_list)):
out_string += str(
sorted_comments[i][0]) + " : " + utils.time_stamp_to_date(
sorted_comments[i]
[2]) + " : " + sorted_comments[i][1] + "\n\n"
out_string += "\n\n"
utils.json_to_file(top_coins, 'reddit_top_coins.json')
utils.clear_and_write_to_file('reddit_info.txt', out_string)
utils.send_to_ftp_server('reddit_info.txt')
def __init__(self, bittrex_api, reddit_api, total_slots):
self.bittrex_api = bittrex_api
self.reddit_api = reddit_api
self.total_slots = total_slots
self.bittrex_coins = utils.get_updated_bittrex_coins()
self.held_coins = utils.file_to_json("held_coins.json")
self.pending_orders = utils.file_to_json("pending_orders.json")
self.coins_ranked_by_mentions = ('CoinName', 0)
self.coins_ranked_by_upvotes = ('CoinName', 0)
self.initialize_reddit_coins()
def add_to_keltner_coins(self, market):
t = {}
t['market'] = market
t['price_data_seconds'] = []
t['price_data_minutes'] = []
t['tr_data'] = []
t['atr_data'] = []
t['ema_data'] = []
t['upper_band_data'] = []
t['middle_band_data'] = []
t['lower_band_data'] = []
self.keltner_coins[market] = t
utils.json_to_file(self.keltner_coins, "keltner_coins.json")
def low_high_buy_strat(self, total_bitcoin):
top_reddit_coins = utils.file_to_json('reddit_top_coins.json')
markets_to_ignore = ['BTC-ETH', 'BTC-BTC']
for rank in range(len(top_reddit_coins)):
market = top_reddit_coins[str(rank)]['market']
if market not in markets_to_ignore:
slots_open = self.total_slots - len(self.held_coins) - len(
self.pending_orders['Buying']) - len(
self.pending_orders['Selling'])
bitcoin_to_use = float(total_bitcoin / (slots_open + .25))
coins_pending_buy = [
market for market in self.pending_orders['Buying']
]
coins_pending_sell = [
market for market in self.pending_orders['Selling']
]
if market not in self.held_coins and market not in coins_pending_buy and market not in \
coins_pending_sell:
percent_change_24h = utils.get_percent_change_24h(
self.bittrex_coins[market])
coin_low_bars = utils.file_to_json('coin_low_bars.json')
low_bar = coin_low_bars[market]
if percent_change_24h <= self.desired_low_point and percent_change_24h <= low_bar:
coin_low_bars[market] = low_bar - 10
utils.json_to_file(coin_low_bars, 'coin_low_bars.json')
elif low_bar != self.desired_low_point and percent_change_24h > low_bar + 10:
self.update_bittrex_coins()
coin_price = float(self.bittrex_coins[market]['Last'])
amount = bitcoin_to_use / coin_price
if amount > 0:
result = utils.buy(self.api, market, amount,
coin_price, percent_change_24h,
self.desired_gain, 0)
if not result['success']:
utils.print_and_write_to_logfile(
"Failed to make buy order " + market)
else:
utils.print_and_write_to_logfile(
"Attempting buy order of " + str(amount) +
" of " + market)
def find_mentions(self, string, reddit_coins, mentioned_id, mentioned_time,
upvotes):
submissions = reddit_coins['submissions']
del reddit_coins['submissions']
coins_with_common_names = utils.file_to_json(
'coins_to_dismiss.json')['coins_with_common_names']
for symbol in reddit_coins:
full_name = reddit_coins[symbol]['full_name']
full_name_reg = r"\b" + full_name + r"\b"
symbol_reg = r"\b" + symbol + r"\b"
if symbol not in coins_with_common_names:
if re.search(symbol_reg, string, re.IGNORECASE) or re.search(
full_name_reg, string, re.IGNORECASE):
reddit_coins = self.add_to_reddit_coin(
reddit_coins, symbol, mentioned_id, mentioned_time,
string, upvotes)
else:
if symbol.lower() != full_name.lower():
if re.search(symbol_reg, string) or re.search(
full_name_reg, string, re.IGNORECASE):
reddit_coins = self.add_to_reddit_coin(
reddit_coins, symbol, mentioned_id, mentioned_time,
string, upvotes)
else:
if re.search(symbol_reg, string):
reddit_coins = self.add_to_reddit_coin(
reddit_coins, symbol, mentioned_id,
mentioned_time, string, upvotes)
reddit_coins['submissions'] = submissions
return reddit_coins
def find_mentions(self, string, reddit_coins, mentioned_id, mentioned_time,
upvotes):
submissions = reddit_coins['submissions']
del reddit_coins['submissions']
coins_with_common_names = utils.file_to_json(
'coins_to_dismiss.json')['coins_with_common_names']
symbols_and_names_map = {}
for symbol in reddit_coins:
if symbol not in coins_with_common_names:
symbols_and_names_map[symbol] = symbol
full_name = reddit_coins[symbol]['full_name'].lower()
symbols_and_names_map[full_name] = symbol
already_seen = set()
for word in string.split(" "):
lower_case_word = word.lower()
if lower_case_word in symbols_and_names_map:
if lower_case_word not in already_seen and symbols_and_names_map[
lower_case_word] not in lower_case_word:
reddit_coins = self.add_to_reddit_coin(
reddit_coins, symbols_and_names_map[lower_case_word],
mentioned_id, mentioned_time, string, upvotes)
already_seen.add(lower_case_word)
already_seen.add(symbols_and_names_map[lower_case_word])
reddit_coins['submissions'] = submissions
return reddit_coins
def add_to_top_coins(self, market, top_coins, rank):
coin_info = self.bittrex_coins[market]
t = {}
t['market'] = market
t['cur_price'] = coin_info['Last']
t['24h_change'] = utils.get_percent_change_24h(coin_info)
top_coins[rank] = t
def add_to_reddit_coin(self, reddit_coins, symbol, mentioned_id,
mentioned_time, string, upvotes):
reddit_coins[symbol]['mentioned_ids'].append(mentioned_id)
reddit_coins[symbol]['mentioned_times'].append(mentioned_time)
reddit_coins[symbol]['text'].append(string)
reddit_coins[symbol]['upvotes'].append(upvotes)
reddit_coins[symbol]['sentiments'].append(utils.get_sentiment(string))
return reddit_coins
def rank_by_upvotes(self):
reddit_coins = utils.file_to_json('reddit_coins.json')
del reddit_coins['submissions']
ranked_coins = {}
for coin in reddit_coins:
ranked_coins[coin] = sum(reddit_coins[coin]['upvotes'])
sorted_coins = sorted(ranked_coins.items(),
key=operator.itemgetter(1),
reverse=True)
self.coins_ranked_by_upvotes = sorted_coins
def __init__(self, api, keltner_period, keltner_multiplier, keltner_slots,
lowest_rank):
self.api = api
self.keltner_period = keltner_period
self.keltner_multiplier = keltner_multiplier
self.keltner_slots = keltner_slots
self.lowest_rank = lowest_rank
self.keltner_coins = utils.file_to_json("keltner_coins.json")
self.coinmarketcap_coins = self.update_coinmarketcap_coins()
self.bittrex_coins = self.update_bittrex_coins(
self.coinmarketcap_coins)
self.held_coins = utils.file_to_json("held_coins.json")
self.pending_orders = utils.file_to_json("pending_orders.json")
self.reset_keltner_coins()
self.ten_second_count = 0
def update_reddit_coins(self):
reddit_coins = utils.file_to_json('reddit_coins.json')
for submission in self.reddit_api.subreddit('CryptoCurrency').top(
'day'):
if submission not in reddit_coins['submissions']:
reddit_coins = self.find_mentions(submission.title,
reddit_coins,
str(submission),
submission.created,
submission.score)
for comment in submission.comments:
reddit_coins = self.find_mentions(comment.body,
reddit_coins,
str(comment),
comment.created,
comment.score)
reddit_coins['submissions'].append(str(submission))
utils.json_to_file(reddit_coins, 'reddit_coins.json')
self.rank_by_mentions()
self.rank_by_upvotes()
def __init__(self, api, buy_min_percent, buy_max_percent,
buy_desired_1h_change, total_slots, data_ticks_to_save):
self.api = api
self.buy_min_percent = buy_min_percent
self.buy_max_percent = buy_max_percent
self.buy_desired_1h_change = buy_desired_1h_change
self.total_slots = total_slots
self.data_ticks_to_save = data_ticks_to_save
self.bittrex_coins = utils.get_updated_bittrex_coins()
self.coinmarketcap_coins = utils.get_updated_coinmarketcap_coins()
self.historical_coin_data = {}
self.refresh_held_pending_history()
self.held_coins = utils.file_to_json("held_coins.json")
self.pending_orders = utils.file_to_json("pending_orders.json")
self.history_coins = utils.file_to_json(
"coin_highest_price_history.json")
def buy(self, market, total_bitcoin):
coins_pending_buy = [
market for market in self.pending_orders['Buying']
]
coins_pending_sell = [
market for market in self.pending_orders['Selling']
]
if market not in self.held_coins and market not in coins_pending_buy and market not in \
coins_pending_sell:
slots_open = self.total_slots - len(self.held_coins) - len(
self.pending_orders['Buying']) - len(
self.pending_orders['Selling'])
bitcoin_to_use = float(total_bitcoin / (slots_open + .25))
coin_price = float(self.bittrex_coins[market]['Last'])
amount = bitcoin_to_use / coin_price
if amount > 0:
percent_change_24h = utils.get_percent_change_24h(
self.bittrex_coins[market])
result = utils.buy(self.api, market, amount, coin_price,
percent_change_24h, 0, 0)
if result['success']:
utils.print_and_write_to_logfile('Buy order of' +
str(amount) + 'of' +
market + 'Unsuccessful')
else:
utils.print_and_write_to_logfile('Buy order of' +
str(amount) + 'of' +
market + 'Successful')
return result
def run_percent_strat():
ps.refresh_held_pending_history()
ps.update_bittrex_coins()
ps.historical_coin_data = utils.update_historical_coin_data(
ps.historical_coin_data, ps.bittrex_coins, ps.data_ticks_to_save)
ps.update_coinmarketcap_coins()
if total_bitcoin > satoshi_50k:
ps.percent_buy_strat(total_bitcoin)
ps.percent_sell_strat()
time.sleep(10)
def rank_by_upvotes_and_sentiment(self):
reddit_coins = utils.file_to_json('reddit_coins.json')
del reddit_coins['submissions']
ranked_coins = {}
for coin in reddit_coins:
upvote_list = reddit_coins[coin]['upvotes']
sentiment_list = reddit_coins[coin]['sentiments']
rank = 0
for i in range(len(upvote_list)):
rank += upvote_list[i] * sentiment_list[i]
ranked_coins[coin] = rank
sorted_coins = sorted(ranked_coins.items(),
key=operator.itemgetter(1),
reverse=True)
self.coins_ranked_by_upvotes_and_sentiment = sorted_coins
def low_high_sell_strat(self):
for market in self.held_coins:
cur_price = float(self.bittrex_coins[market]['Last'])
bought_price = self.held_coins[market]['price_bought']
change = utils.percent_change(bought_price, cur_price)
desired_gain = self.held_coins[market]['desired_gain']
high_bar = self.held_coins[market]['high_bar']
if change >= desired_gain and change >= high_bar:
self.held_coins[market]['high_bar'] = high_bar + 10
utils.json_to_file(self.held_coins, 'held_coins.json')
elif high_bar != desired_gain and change < high_bar - 10:
coin_to_sell = utils.get_second_market_coin(market)
balance = self.api.get_balance(coin_to_sell)
if balance['success']:
amount = float(balance['result']['Available'])
self.update_bittrex_coins()
utils.sell(self.api, amount, market, self.bittrex_coins)
else:
utils.print_and_write_to_logfile("Could not retrieve balance: " + balance['message'])
def reddit_buy_strat(self, total_bitcoin):
coin_rank = 0
coins_to_dismiss = utils.file_to_json(
'coins_to_dismiss.json')["coins_to_dismiss"]
slots_open = self.total_slots - len(self.held_coins) - len(
self.pending_orders['Buying']) - len(
self.pending_orders['Selling'])
while coin_rank < 5:
cur_coin = self.rank_by_upvotes()[coin_rank][0]
if cur_coin not in coins_to_dismiss:
market = "BTC-" + cur_coin
coins_pending_buy = [
market for market in self.pending_orders['Buying']
]
coins_pending_sell = [
market for market in self.pending_orders['Selling']
]
if market not in self.held_coins and market not in coins_pending_buy and market not in \
coins_pending_sell:
bitcoin_to_use = float(total_bitcoin / (slots_open + .25))
coin_price = float(self.bittrex_coins[market]['Last'])
amount = bitcoin_to_use / coin_price
if amount > 0:
percent_change_24h = utils.get_percent_change_24h(
self.bittrex_coins[market])
buy_request = utils.buy(self.api, market, amount,
coin_price, percent_change_24h,
0)
if buy_request['success']:
utils.print_and_write_to_logfile("Buy order of " +
str(amount) +
" " + market +
" requested")
else:
utils.print_and_write_to_logfile(
buy_request['message'])
if cur_coin not in coins_to_dismiss:
coin_rank += 1
