class TestPoloniexPrivateWithoutToken(unittest.TestCase): def setUp(self): self.poloniex = Poloniex('', '') def test_exception(self): with self.assertRaises(HTTPError): self.poloniex.returnBalances()
class Polo: def __init__(self): self.public = Poloniex() self.private = Poloniex(API_Key, API_Secret) self.watch() def watch(self): res = self.private.returnBalances() self.btc = float(res['BTC']) self.usd = float(res['USDT']) self.xrp = float(res['XRP']) self.xem = float(res['XEM']) self.ltc = float(res['LTC']) self.eth = float(res['ETH']) res = self.public.returnOrderBook(Currency_Pair) self.ask = [float(res['asks'][0][0]), float(res['asks'][0][1])] self.bid = [float(res['bids'][0][0]), float(res['bids'][0][1])] def sell(self, am): self.private.sell('USDT_BTC', self.bid[0], am) self.watch() def buy(self, am): self.private.buy('USDT_BTC', self.ask[0], am) self.watch()
class Poloniex: def __init__(self, key, secret): self.logger = Logger(__name__) try: self.client = Client(key, secret) except Exception as e: self.logger.log(e) raise ExchangeException(self.__class__.__name__, e) def getBalances(self): try: result = self.client.returnBalances() balances = {} for currency in result: name = currency.upper() value = float(result[currency]) if value >= Config.BALANCE_ZERO: balances[name] = value return balances except Exception as e: self.logger.log(e) raise ExchangeException(self.__class__.__name__, e)
def sell_everything(currency): api_key = getkeys()[0] api_secret = getkeys()[1] polo = Poloniex(api_key, api_secret) pair = 'USDT_{}'.format(currency) recap = sell_asset(pair = pair, amount = polo.returnBalances()[currency]) return(recap)
class PoloniexApiClient(BaseApiClient): PAIR_NAME_TEMPLATE = '{quote}_{base}' def __init__(self): super(PoloniexApiClient, self).__init__() self.api = self.get_api() def get_api(self): if not self.api: self.api = Poloniex(settings.API4_KEY, settings.API4_SECRET) return self.api def get_balance(self, currency): return Decimal(str(self.api.returnBalances().get(currency.code))) def get_ticker(self, pair): market = self.PAIR_NAME_TEMPLATE.format( base=pair.base.code, quote=pair.quote.code, ) return self.api.returnTicker().get(market) def get_rate(self, pair, **kwargs): ticker = self.get_ticker(pair) rate = ticker.get('last') return Decimal(str(rate)) def buy_limit(self, pair, amount, rate=None): market = self.PAIR_NAME_TEMPLATE.format( base=pair.base.code, quote=pair.quote.code, ) if not rate: rate = float(self.get_rate(pair)) return self.api.buy(market, rate, amount) def sell_limit(self, pair, amount, rate=None): market = self.PAIR_NAME_TEMPLATE.format( base=pair.base.code, quote=pair.quote.code, ) if not rate: rate = float(self.get_rate(pair)) return self.api.sell(market, rate, amount) def release_coins(self, currency, address, amount): tx_id = None if isinstance(currency, Currency): currency = currency.code if isinstance(address, Address): address = address.address res = self.api.withdraw(currency, amount, address) self.logger.info('Response from Poloniex withdraw: {}'.format(res)) success = 'Withdrew' in res.get('response', '') if success: tx_id = res.get('response') return tx_id, success
class TestPoloniexPrivate(unittest.TestCase): def setUp(self): apiKey = os.environ.get('API_KEY', False) apiSecret = os.environ.get('API_SECRET', False) if not apiKey or not apiSecret: self.skipTest('private keys not provided') self.poloniex = Poloniex(apiKey, apiSecret) def test_balances(self): res = self.poloniex.returnBalances() assert 'BTC' in res assert 'ETH' in res
class Poloniex: def __init__(self, key, secret): self.client = Client(key, secret) self.logger = Logger(__name__) def getBalances(self): try: result = self.client.returnBalances() balances = {} for currency in result: name = currency.encode('utf-8').upper() value = float(result[currency]) if value > 0.0: balances[name] = value return balances except Exception as e: self.logger.log(e) raise ExchangeException(self.__class__.__name__, e.message)
class Polo(Base): """ Poloniex interface """ arg_parser = configargparse.get_argument_parser() arg_parser.add('--polo_api_key', help='polo_api_key') arg_parser.add("--polo_secret", help='polo_secret') arg_parser.add("--polo_txn_fee", help='Poloniex txn. fee') arg_parser.add("--polo_buy_order", help='Poloniex buy order type') arg_parser.add("--polo_sell_order", help='Poloniex sell order type') valid_candle_intervals = [300, 900, 1800, 7200, 14400, 86400] def __init__(self): args = self.arg_parser.parse_known_args()[0] super(Polo, self).__init__() api_key = args.polo_api_key secret = args.polo_secret self.transaction_fee = float(args.polo_txn_fee) self.polo = Poloniex(api_key, secret) self.buy_order_type = args.polo_buy_order self.sell_order_type = args.polo_sell_order self.verbosity = args.verbosity self.pair_delimiter = '_' self.tickers_cache_refresh_interval = 50 # If the ticker request is within the interval, get data from cache self.last_tickers_fetch_epoch = 0 # self.last_tickers_cache = None # Cache for storing immediate tickers def get_balances(self): """ Return available account balances (function returns ONLY currencies > 0) """ try: balances = self.polo.returnBalances() only_non_zeros = { k: float(v) for k, v in balances.items() if float(v) > 0.0 } except PoloniexError as e: print( colored('!!! Got exception (polo.get_balances): ' + str(e), 'red')) only_non_zeros = dict() return only_non_zeros def get_symbol_ticker(self, symbol, candle_size=5): """ Returns real-time ticker Data-Frame for given symbol/pair Info: Currently Poloniex returns tickers for ALL pairs. To speed the queries and avoid unnecessary API calls, this method implements temporary cache """ epoch_now = int(time.time()) if epoch_now < (self.last_tickers_fetch_epoch + self.tickers_cache_refresh_interval): # If the ticker request is within cache_fetch_interval, try to get data from cache pair_ticker = self.last_tickers_cache[symbol].copy() else: # If cache is too old fetch data from Poloniex API try: ticker = self.polo.returnTicker() pair_ticker = ticker[symbol] self.last_tickers_fetch_epoch = int(time.time()) self.last_tickers_cache = ticker.copy() except (PoloniexError | JSONDecodeError) as e: print( colored( '!!! Got exception in get_symbol_ticker. Details: ' + str(e), 'red')) pair_ticker = self.last_tickers_cache[symbol].copy() pair_ticker = dict.fromkeys(pair_ticker, None) df = pd.DataFrame.from_dict(pair_ticker, orient="index") df = df.T # We will use 'last' price as closing one df = df.rename(columns={'last': 'close', 'baseVolume': 'volume'}) df['close'] = df['close'].astype(float) df['volume'] = df['volume'].astype(float) df['pair'] = symbol df['date'] = int(datetime.datetime.utcnow().timestamp()) return df def return_ticker(self): """ Returns ticker for all currencies """ return self.polo.returnTicker() def cancel_order(self, order_number): """ Cancels order for given order number """ return self.polo.cancelOrder(order_number) def return_open_orders(self, currency_pair='all'): """ Returns your open orders """ return self.polo.returnOpenOrders(currency_pair) def get_pairs(self): """ Returns ticker pairs for all currencies """ ticker = self.polo.returnTicker() return list(ticker) def get_candles_df(self, currency_pair, epoch_start, epoch_end, period=False): """ Returns candlestick chart data in pandas dataframe """ try: data = self.get_candles(currency_pair, epoch_start, epoch_end, period) df = pd.DataFrame(data) df = df.tail(1) df['close'] = df['close'].astype(float) df['volume'] = df['volume'].astype(float) df['pair'] = currency_pair return df except (PoloniexError, JSONDecodeError) as e: print() print( colored( '!!! Got exception while retrieving polo data:' + str(e) + ', pair: ' + currency_pair, 'red')) return pd.DataFrame() def get_candles(self, currency_pair, epoch_start, epoch_end, interval_in_sec=False): """ Returns candlestick chart data """ candle_interval = self.get_valid_candle_interval(interval_in_sec) data = [] try: data = self.polo.returnChartData(currency_pair, candle_interval, epoch_start, epoch_end) except (PoloniexError, JSONDecodeError) as e: print() print( colored( '!!! Got exception while retrieving polo data:' + str(e) + ', pair: ' + currency_pair, 'red')) return data def get_valid_candle_interval(self, period_in_sec): """ Returns closest value from valid candle intervals """ if not period_in_sec: return period_in_sec if period_in_sec in self.valid_candle_intervals: return period_in_sec # Find the closest valid interval return min(self.valid_candle_intervals, key=lambda x: abs(x - period_in_sec)) def trade(self, actions, wallet, trade_mode): if trade_mode == TradeMode.backtest: return Base.trade(actions, wallet, trade_mode) else: actions = self.life_trade(actions) return actions def life_trade(self, actions): """ Places orders and returns order number !!! For now we are NOT handling postOnly type of orders !!! """ for action in actions: if action.action == TradeState.none: actions.remove(action) continue # Handle buy_sell mode wallet = self.get_balances() if action.buy_sell_mode == BuySellMode.all: action.amount = self.get_buy_sell_all_amount(wallet, action) elif action.buy_sell_mode == BuySellMode.fixed: action.amount = self.get_fixed_trade_amount(wallet, action) if self.verbosity: print( 'Processing live-action: ' + str(action.action) + ', amount:', str(action.amount) + ', pair:', action.pair + ', rate:', str(action.rate) + ', buy_sell_mode:', action.buy_sell_mode) # If we don't have enough assets, just skip/remove the action if action.amount == 0.0: print( colored( 'No assets to buy/sell, ...skipping: ' + str(action.amount) + ' ' + action.pair, 'green')) actions.remove(action) continue # ** Buy Action ** if action.action == TradeState.buy: try: print( colored( 'Setting buy order: ' + str(action.amount) + '' + action.pair, 'green')) action.order_number = self.polo.buy( action.pair, action.rate, action.amount, self.buy_order_type) except PoloniexError as e: print( colored( 'Got exception: ' + str(e) + ' Txn: buy-' + action.pair, 'red')) continue amount_unfilled = action.order_number.get('amountUnfilled') if float(amount_unfilled) == 0.0: actions.remove(action) print( colored( 'Bought: ' + str(action.amount) + '' + action.pair, 'green')) else: action.amount = amount_unfilled print( colored( 'Not filled 100% buy txn. Unfilled amount: ' + str(amount_unfilled) + '' + action.pair, 'red')) # ** Sell Action ** elif action.action == TradeState.sell: try: print( colored( 'Setting sell order: ' + str(action.amount) + '' + action.pair, 'yellow')) action.order_number = self.polo.sell( action.pair, action.rate, action.amount, self.buy_order_type) except PoloniexError as e: print( colored( 'Got exception: ' + str(e) + ' Txn: sell-' + action.pair, 'red')) continue amount_unfilled = action.order_number.get('amountUnfilled') if float(amount_unfilled) == 0.0: actions.remove(action) print( colored( 'Sold: ' + str(action.amount) + '' + action.pair, 'yellow')) else: action.amount = amount_unfilled print( colored( 'Not filled 100% sell txn. Unfilled amount: ' + str(amount_unfilled) + '' + action.pair, 'red')) return actions
exit(1) # Exit the entire script while True: #1 get the ticker of the coinpair (LowestAsk & HighestBid Price) try: Ask = polo.returnTicker()[pair]['lowestAsk'] # Collect latest Sell(ask) & Buy (bid) prices Bid = polo.returnTicker()[pair]['highestBid'] #print("Sell price in BTC = " , Ask) #print("Buy price in BTC = " , Bid) break except: backoff("Can not get the Ask and Bid Price") exit(1) while True: #2 Get the total amount of altcoins try: AltTotal = polo.returnBalances()[AltCoin] # Get the amount of the altcoin #print("I have total ", AltCoin ,"= " , AltTotal) break except: backoff("Can not get the total amount of coins") exit(1) while True: #3 calculate the total Alt Worth in BTC try: AltWorth = float(Bid) * float(AltTotal) # Float for numbers with decimals (Bid see #1) (AltTotal see #2) #print("My" , AltCoin , "worth in BTC = " , AltWorth) break except: backoff("Can not calculate altcoin total worth") exit(1)
# Number of hours to wait in between each withdrawal poloniexwithdrawalhours = 24 # Sleep delay in seconds... wait 10 mins longer than 24 hours each day (API withdrawal resets every day) sleepdelay = (poloniexwithdrawalhours * 3600) + (10 * 60) # Target withdrawal address xmraddress = "474e5p5omsLHxa9DmmKAPfJYrGh2WZZx7MwL92rn8Xic6nw2w5N24m8c2HuZxTi1qhQMtsD9dogi7CZbk4KBhYQ6R4acCH8" ############################# # Query XMR balance and prices ############################# # Get XMR balance balances = bot.returnBalances() xmrbalance = balances.get("XMR", "NOTFOUND") print(xmrbalance) # Get XMR last price # {u'tradeID': 284125, u'amount': u'0.00694697', u'rate': u'13.08253989', ...etc.. trades = bot.returnMarketTradeHistory("USDT_XMR") for trade in trades: xmrprice = float(trade.get("rate", "noprice")) xmrpricedate = trade.get("date", "nopricedate") print("Latest XMR price " + str(xmrprice) + " xmr (as of " + str(xmrpricedate) + ")") break ############################# # Withdraw XMR - make sure you really want to do this!
class Polo(Base): """ Poloniex interface """ def __init__(self, config, verbosity=2): super(Polo, self).__init__() api_key = config['api_key'] secret = config['secret'] self.transaction_fee = float(config['transaction_fee']) self.polo = Poloniex(api_key, secret) self.buy_order_type = config['buy_order_type'] self.sell_order_type = config['sell_order_type'] self.verbosity = verbosity self.pair_delimiter = '_' def get_balances(self): """ Return available account balances (function returns ONLY currencies > 0) """ try: balances = self.polo.returnBalances() only_non_zeros = { k: float(v) for k, v in balances.items() if float(v) > 0.0 } except PoloniexError as e: print( colored('!!! Got exception (polo.get_balances): ' + str(e), 'red')) only_non_zeros = dict() return only_non_zeros def get_symbol_ticker(self, symbol, candle_size=5): """ Returns real-time ticker Data-Frame """ ticker = self.polo.returnTicker()[symbol] df = pd.DataFrame.from_dict(ticker, orient="index") df = df.T # We will use 'last' price as closing one df = df.rename(columns={'last': 'close', 'baseVolume': 'volume'}) df['close'] = df['close'].astype(float) df['volume'] = df['volume'].astype(float) df['pair'] = symbol df['date'] = int(datetime.datetime.utcnow().timestamp()) return df def return_ticker(self): """ Returns ticker for all currencies """ return self.polo.returnTicker() def cancel_order(self, order_number): """ Cancels order for given order number """ return self.polo.cancelOrder(order_number) def return_open_orders(self, currency_pair='all'): """ Returns your open orders """ return self.polo.returnOpenOrders(currency_pair) def get_pairs(self): """ Returns ticker pairs for all currencies """ ticker = self.polo.returnTicker() return list(ticker) def return_candles(self, currency_pair, epoch_start, epoch_end, period=False): """ Returns candlestick chart data """ data = [] try: data = self.polo.returnChartData(currency_pair, period, epoch_start, epoch_end) except (PoloniexError, JSONDecodeError) as e: print() print( colored( '!!! Got exception while retrieving polo data:' + str(e) + ', pair: ' + currency_pair, 'red')) return data def trade(self, actions, wallet, trade_mode): if trade_mode == TradeMode.backtest: return Base.trade(actions, wallet, trade_mode) else: actions = self.life_trade(actions) return actions def life_trade(self, actions): """ Places orders and returns order number !!! For now we are NOT handling postOnly type of orders !!! """ for action in actions: if action.action == TradeState.none: actions.remove(action) continue # Handle buy_sell_all cases wallet = self.get_balances() if action.buy_sell_all: action.amount = self.get_buy_sell_all_amount(wallet, action) if self.verbosity > 0: print( 'Processing live-action: ' + str(action.action) + ', amount:', str(action.amount) + ', pair:', action.pair + ', rate:', str(action.rate) + ', buy_sell_all:', action.buy_sell_all) # If we don't have enough assets, just skip/remove the action if action.amount == 0.0: print( colored( 'No assets to buy/sell, ...skipping: ' + str(action.amount) + ' ' + action.pair, 'green')) actions.remove(action) continue # ** Buy Action ** if action.action == TradeState.buy: try: print( colored( 'Setting buy order: ' + str(action.amount) + '' + action.pair, 'green')) action.order_number = self.polo.buy( action.pair, action.rate, action.amount, self.buy_order_type) except PoloniexError as e: print( colored( 'Got exception: ' + str(e) + ' Txn: buy-' + action.pair, 'red')) continue amount_unfilled = action.order_number.get('amountUnfilled') if float(amount_unfilled) == 0.0: actions.remove(action) print( colored( 'Bought: ' + str(action.amount) + '' + action.pair, 'green')) else: action.amount = amount_unfilled print( colored( 'Not filled 100% buy txn. Unfilled amount: ' + str(amount_unfilled) + '' + action.pair, 'red')) # ** Sell Action ** elif action.action == TradeState.sell: try: print( colored( 'Setting sell order: ' + str(action.amount) + '' + action.pair, 'yellow')) action.order_number = self.polo.sell( action.pair, action.rate, action.amount, self.buy_order_type) except PoloniexError as e: print( colored( 'Got exception: ' + str(e) + ' Txn: sell-' + action.pair, 'red')) continue amount_unfilled = action.order_number.get('amountUnfilled') if float(amount_unfilled) == 0.0: actions.remove(action) print( colored( 'Sold: ' + str(action.amount) + '' + action.pair, 'yellow')) else: action.amount = amount_unfilled print( colored( 'Not filled 100% sell txn. Unfilled amount: ' + str(amount_unfilled) + '' + action.pair, 'red')) return actions
class poloniex_functions(object): def __init__(self): self.output = BotLog() self.conn = Poloniex('secret', 'key') def getBalance(self): while True: try: balData = { k: v for k, v in self.conn.returnBalances().items() if float(v) != 0 } break except Exception as e: self.output.log("Error: " + str(e)) time.sleep(20) continue return balData def getCurrencies(self): while True: try: tickData = [k for k, v in self.conn.returnTicker().items()] break except Exception as e: self.output.log("Error: " + str(e)) time.sleep(20) continue return tickData def getNextTick(self, pair): while True: try: tickData = self.conn.returnTicker()[pair] break except Exception as e: self.output.log("Error: " + str(e)) time.sleep(20) continue return tickData def getHistoricTicks(self, pair, startTime, endTime, period): while True: try: result = self.conn.returnChartData(currencyPair=pair, start=startTime, end=endTime, period=period) break except Exception as e: self.output.log("Error: " + str(e)) time.sleep(20) continue return result def sell(self, pair, rate, amount): try: result = self.conn.sell(currencyPair=pair, rate=rate, amount=amount) except Exception as e: self.output.log("Error: " + str(e)) time.sleep(20) return result def buy(self, pair, rate, amount): try: result = self.conn.buy(currencyPair=pair, rate=rate, amount=amount) except Exception as e: self.output.log("Error: " + str(e)) time.sleep(20) return result def returnOrderTrades(self, orderId): while True: try: result = self.conn.returnOrderTrades(orderId) break except Exception as e: self.output.log("Error: " + str(e)) time.sleep(20) continue return result #============================================================================== # Returns your open orders for a given market, specified by the "currencyPair" POST parameter, # e.g. "BTC_XCP". Set "currencyPair" to "all" to return open orders for all markets. Sample output for single market: #============================================================================== def returnOpenOrders(self, currencyPair='All'): while True: try: result = self.conn.returnOpenOrders(currencyPair) break except Exception as e: self.output.log("Error: " + str(e)) time.sleep(20) continue return result #============================================================================== # Cancels an order you have placed in a given market. Required POST parameter is "orderNumber". If successful, the method will return: #============================================================================== def cancelOrder(self, orderNumber): while True: try: result = self.conn.cancelOrder(orderNumber) break except Exception as e: self.output.log("Error: " + str(e)) time.sleep(20) continue return result #============================================================================== # Cancels an order and places a new one of the same type in a single atomic transaction, meaning either both operations will succeed or both will fail. # Required POST parameters are "orderNumber" and "rate"; you may optionally specify "amount" if you wish to change # the amount of the new order. "postOnly" or "immediateOrCancel" may be specified for exchange orders, but will have no effect on margin orders. #============================================================================== def moveOrder(self, orderNumber, rate, amount): while True: try: result = self.conn.moveOrder(orderNumber, rate, amount) break except Exception as e: self.output.log("Error: " + str(e)) time.sleep(20) continue return result
GDAX = gdax.PublicClient() my_gdax = gdax.AuthenticatedClient( 'afb5c86acff788d5f92f11464778b3fc', 'bhG2QcCgdYhxUrdYtaGC2RI6rgZ/3nnD4iIk44fkm1ddLflIA5MESMfiAVF7FM3LAe0NFJ8LJ3O3kM+1eCUXgA==', 'phrigmphragm69') polo = Poloniex( 'VVON608N-R94HR9YS-IBLCJJPZ-SZ6BNQO9', 'f122cbc7d88c083b9c60483d6d7be5637b8ba808812bafa678fb87d6a04a5ae5d54b3b7dc04422366e41bbfc5e491f073a2b328c8a453918c7537c48ef465311' ) Bitfinex = bitfinex.Client() gem = Geminipy(api_key='', secret_key='', live=True) my_bittrex = Bittrex('2a1e0d61c5804c1fa2f36f7bd5abe293', '98558cc7b793450d8290630010550994', api_version=API_V2_0) poloBalance = polo.returnBalances() print(polo.returnTicker()['BTC_ETH']) # print(Bitfinex.ticker('ETHBTC')) #" # AUTHENTICATION - DO NOT F**K WITH THIS # " print("polo call") print(float(dict.get(polo.returnTicker()['BTC_ETH'], 'last'))) # print("bittrex call") # print(my_bittrex.get_balance('OMG'))
# for line in result : # t= float(re.search(r'\d+', str(line)).group()) # TestingData.append(t) # print(TestingData) polo = Poloniex( 'QHKEQWBN-667F2YR6-QZ1WM5OX-VVB4GBSX', 'f7bc3077b4df19ffa9932253aeb329821b1377a2ba6c274b797f599e9ba555a5282fd032f539c416087dc5afcacade3fef6dd00f527910ed92a4c8be1ea13c15' ) # ForRealTime while (True): print(datetime.now().strftime("%H:%M:%S")) IsNextOperationBuy = not IsNextOperationBuy ticker = polo.returnTicker()['USDC_BTC']['last'] # lowestAsk = polo.returnTicker()['USDC_BTC']['lowestAsk'] balances = polo.returnBalances()['BTC'] if IsNextOperationBuy == True: totalMain = [] totalMain = tryToBuy(ticker, BalanceUSD, BalanceBTC) print(totalMain) # BalanceBTC = totalMain[0] # BalanceUSDT = totalMain[1] elif IsNextOperationBuy == False: totalMain = [] print(ticker + BalanceUSD + BalanceBTC) totalMain = tryToSell(ticker, BalanceUSD, BalanceBTC) print(totalMain) BalanceBTC = totalMain[0] BalanceUSDT = totalMain[1] # totalMain = attemptToMakeTrade(IsNextOperationBuy,ticker,BalanceUSD,BalanceBTC,total) | as part of buying using thresholds
class Trader(object): def __init__(self, api_key, api_secret, coin, currency, dust_total=10, dust_amount=100.0, min_spread=0.0001, max_trading_amount=1): # set currency pair self.coin = coin self.currency = currency self.my_pair = '%s_%s' % (currency, coin) # we'll need this while finding buy/sell prices self.dust_total = self.make_satoshi(dust_total) self.dust_amount = self.make_satoshi(dust_amount) self.min_spread = self.make_satoshi(min_spread) self.max_trading_amount = self.make_satoshi(max_trading_amount) # initialize the poloniex api self.api_key = api_key self.api_secret = api_secret self.polo = Poloniex(api_key, api_secret) # initialize other variables self.coin_balance = self.make_satoshi('0.0') self.currency_balance = self.make_satoshi('0.0') self.total_coin_balance = self.make_satoshi('0.0') self.total_currency_balance = self.make_satoshi('0.0') self.open_orders_raw = [] self.open_orders = [] self.open_orders_sell = [] self.open_orders_buy = [] self.order_book_raw = [] self.order_book = {} self.order_book["buy"] = [] self.order_book["sell"] = [] self.sell_price = self.make_satoshi('0.0') self.buy_price = self.make_satoshi('0.0') self.price_spread = self.make_satoshi('0.0') self.sell_amount = self.make_satoshi('0.0') self.buy_amount = self.make_satoshi('0.0') self.trade = False # those are hardcoded. may be added to settings later. self.min_currency_balance = self.make_satoshi('0.00100000') # seconds to wait for exchange rate limits. self.exchange_wait_time = 0.8 def make_satoshi(self, num): return decimal.Decimal(num).quantize(decimal.Decimal('1.00000000')) def load_open_orders(self): # loads open orders. Resets the balances so load_balances method should be called after. self.total_coin_balance = self.make_satoshi('0.0') self.total_currency_balance = self.make_satoshi('0.0') self.open_orders_raw = self.polo.returnOpenOrders( currencyPair=self.my_pair) self.open_orders = [] self.open_orders_sell = [] self.open_orders_buy = [] for item in self.open_orders_raw: order = {} order['type'] = item['type'] order["order_number"] = item['orderNumber'] order["price"] = self.make_satoshi(item['rate']) order["amount"] = self.make_satoshi(item['amount']) order["total"] = self.make_satoshi(order['price'] * order['amount']) order["starting_amount"] = self.make_satoshi( item['startingAmount']) self.open_orders.append(order) if order['type'] == 'sell': self.open_orders_sell.append(order) self.total_coin_balance = self.total_coin_balance + order[ "amount"] else: self.open_orders_buy.append(order) self.total_currency_balance = self.total_currency_balance + order[ "total"] return self.open_orders def load_balances(self): # first load the open orders to get the balances in open orders. self.load_open_orders() # request from exchange self.balances = self.polo.returnBalances() # set the coin balance self.coin_balance = self.make_satoshi(self.balances[self.coin]) self.total_coin_balance = self.total_coin_balance + self.coin_balance # '0.00000001' makes things complicated. get rid of it. if self.coin_balance <= self.make_satoshi('0.00000001'): self.coin_balance = self.make_satoshi('0.0') if self.total_coin_balance <= self.make_satoshi('0.00000001'): self.total_coin_balance = self.make_satoshi('0.0') # set the main currency balance self.currency_balance = self.make_satoshi(self.balances[self.currency]) self.total_currency_balance = self.total_currency_balance + self.currency_balance # '0.00000001' makes things complicated. get rid of it. if self.currency_balance <= self.make_satoshi('0.00000001'): self.currency_balance = self.make_satoshi('0.0') if self.total_currency_balance <= self.make_satoshi('0.00000001'): self.total_currency_balance = self.make_satoshi('0.0') # added for debugging. make the BTC amount > 0 so we can test buying. # self.total_currency_balance = self.make_satoshi('0.10000000') def load_order_book(self): self.order_book_raw = self.polo.returnOrderBook( currencyPair=self.my_pair, depth='200') self.order_book["buy"] = [] self.order_book["sell"] = [] self.process_order_book('buy', self.order_book_raw["bids"]) self.process_order_book('sell', self.order_book_raw["asks"]) return self.order_book def process_order_book(self, order_type, order_book_raw): self.order_book[order_type] = [] total = self.make_satoshi("0.0") for item in order_book_raw: order = {} order['type'] = order_type order["price"] = self.make_satoshi(item[0]) order["amount"] = self.make_satoshi(item[1]) order["cur"] = self.make_satoshi(order["price"] * order["amount"]) total = self.make_satoshi(total + order["cur"]) order["total"] = total # mark the order if its my order. put order number from open_orders order['order_number'] = None for open_order in self.open_orders: if (open_order['type'] == order['type']) and (open_order["price"] == order["price"]): order["order_number"] = open_order['order_number'] print "order:", order self.order_book[order_type].append(order) return self.order_book[order_type] def find_sell_price(self): total = self.make_satoshi("0.0") for order in self.order_book['sell']: if order['order_number'] is None: total = self.make_satoshi(total + order["cur"]) if (order["amount"] >= dust_amount) or (total >= dust_total): return self.make_satoshi(order["price"] - self.make_satoshi("0.00000003")) return False def find_buy_price(self): total = self.make_satoshi("0.0") for order in self.order_book['buy']: if order['order_number'] is None: total = self.make_satoshi(total + order["cur"]) if (order["amount"] >= dust_amount) or (total >= dust_total): return self.make_satoshi(order["price"] + self.make_satoshi("0.00000003")) return False def decide_to_trade(self): self.sell_price = self.find_sell_price() self.buy_price = self.find_buy_price() self.price_spread = self.sell_price - self.buy_price print "Sell Price:", self.sell_price print "Buy Price:", self.buy_price print "Price Spread:", self.price_spread if (not self.sell_price) or (not self.buy_price): print "Something is wrong with sell and buy prices. Will not trade!" self.trade = False return False if self.total_currency_balance > self.min_currency_balance: print 'I have %s %s, will try to buy %s.' % ( self.total_currency_balance, self.currency, self.coin) self.trade = 'buy' return True else: if self.price_spread >= self.min_spread: print 'Spread is good. Will trade' # sell or buy? if self.total_coin_balance > 0: print 'I have %s %s, will try to sell %s for %s.' % ( self.total_coin_balance, self.coin, self.coin, self.currency) self.trade = 'sell' return True else: print 'I have nothing to trade.' self.trade = False else: print 'Price Spread is not good. Stop trading.' self.trade = False return False def cancel_open_orders(self, buy_sell): for order in self.open_orders: if order['type'] == buy_sell: print "canceling order:", order try: retval = self.polo.cancelOrder(order["order_number"]) except: retval = False print 'ERROR canceling order.' print "cancel order retval:", retval self.open_orders.remove(order) if buy_sell == 'sell': self.open_orders_sell.remove(order) else: self.open_orders_buy.remove(order) def cancel_open_order(self, order): print "canceling order:", order try: retval = self.polo.cancelOrder(order["order_number"]) except: retval = False print 'ERROR canceling order.' time.sleep(0.2) print "cancel order retval:", retval self.open_orders.remove(order) if order['type'] == 'sell': self.open_orders_sell.remove(order) else: self.open_orders_buy.remove(order) def add_sell_order(self): # compute the amount if self.total_coin_balance > self.max_trading_amount: self.sell_amount = self.max_trading_amount else: self.sell_amount = self.total_coin_balance print "self.sell_amount:", self.sell_amount # send order to exchange try: retval = self.polo.sell(currencyPair=self.my_pair, rate=self.sell_price, amount=self.sell_amount) except: print 'ERROR adding SELL order.' retval = False print retval return retval def sell(self): # cancel all buy orders first. self.cancel_open_orders('buy') # check open sell orders if the sell price is ok. for order in self.open_orders_sell: if order['price'] == self.sell_price: print "order is ok:", order else: # cancel the order. retval = self.cancel_open_order(order) print 'self.open_orders_sell:', len(self.open_orders_sell) if len(self.open_orders_sell) == 0: print 'adding a new sell order' retval = self.add_sell_order() def add_buy_order(self): # compute the amount if self.total_currency_balance > self.make_satoshi('0.00001000'): self.buy_amount = self.make_satoshi( self.total_currency_balance / self.buy_price) - self.make_satoshi('0.00000001') print "Buying amount:", self.buy_amount else: print "Buying amount is low. not buying:" return False # send order to exchange try: retval = self.polo.buy(currencyPair=self.my_pair, rate=self.buy_price, amount=self.buy_amount) except: print 'ERROR adding BUY order.' retval = False print retval return retval def buy(self): # cancel all buy orders first. self.cancel_open_orders('sell') # check open sell orders if the sell price is ok. for order in self.open_orders_buy: if order['price'] == self.buy_price: print "order is ok:", order else: # cancel the order. retval = self.cancel_open_order(order) print 'self.open_orders_buy:', len(self.open_orders_buy) if len(self.open_orders_buy) == 0: print 'adding a new buy order' retval = self.add_buy_order() def run_scalping(self): while True: now = datetime.datetime.now() print str(now) self.load_balances() self.load_order_book() print '%s Balance: %s' % (self.currency, self.total_currency_balance) print '%s Balance: %s' % (self.coin, self.total_coin_balance) # trade or not trade? trade = self.decide_to_trade() print "Trade?", trade if self.trade == 'sell': self.sell() elif self.trade == 'buy': self.buy() else: #Will not trade. Cancel all orders. self.cancel_open_orders('buy') self.cancel_open_orders('sell') print "." print "open orders:", self.open_orders print "." now = datetime.datetime.now() print str(now) print "Will wait a little bit for not to flood the exchange..." time.sleep(self.exchange_wait_time) def add_sell_all_order(self): # compute the amount self.sell_amount = self.total_coin_balance print "self.sell_amount:", self.sell_amount if self.sell_amount: # send order to exchange try: retval = self.polo.sell(currencyPair=self.my_pair, rate=self.sell_price, amount=self.sell_amount) except: print 'ERROR adding SELL ALL order.' retval = False print retval return retval else: return False def sell_all(self): # cancel all buy orders first. self.cancel_open_orders('buy') # check open sell orders if the sell price is ok. for order in self.open_orders_sell: if order['price'] == self.sell_price: print "order is ok:", order else: # cancel the order. retval = self.cancel_open_order(order) print 'self.open_orders_sell:', len(self.open_orders_sell) if len(self.open_orders_sell) == 0: print 'adding a new sell all order' retval = self.add_sell_all_order() def run_sell_all(self): self.trade = 'sell' while self.trade == 'sell': now = datetime.datetime.now() print str(now) self.load_balances() self.load_order_book() print '%s Balance: %s' % (self.currency, self.total_currency_balance) print '%s Balance: %s' % (self.coin, self.total_coin_balance) self.sell_price = self.find_sell_price() print "Sell Price:", self.sell_price if self.total_coin_balance > 0.0: print 'I have %s %s, will try to sell %s for %s.' % ( self.total_coin_balance, self.coin, self.coin, self.currency) self.trade = 'sell' else: print 'I have nothing to trade.' self.trade = False if self.trade == 'sell': self.sell_all() else: #Will not trade. Cancel all orders. self.cancel_open_orders('buy') self.cancel_open_orders('sell') print "." print "open orders:", self.open_orders print "." now = datetime.datetime.now() print str(now) print "Will wait a little bit for not to flood the exchange..." time.sleep(self.exchange_wait_time) def add_buy_all_order(self): # compute the amount if self.total_currency_balance > self.make_satoshi('0.00001000'): self.buy_amount = self.make_satoshi( self.total_currency_balance / self.buy_price) - self.make_satoshi('0.00000001') print "Buying amount:", self.buy_amount else: print "Buying amount is low. not buying:" return False # send order to exchange try: retval = self.polo.buy(currencyPair=self.my_pair, rate=self.buy_price, amount=self.buy_amount) except: print 'ERROR adding BUY ALL order.' retval = False print retval return retval def buy_all(self): # cancel all buy orders first. self.cancel_open_orders('sell') # check open sell orders if the sell price is ok. for order in self.open_orders_buy: if order['price'] == self.buy_price: print "order is ok:", order else: # cancel the order. retval = self.cancel_open_order(order) print 'self.open_orders_buy:', len(self.open_orders_buy) if len(self.open_orders_buy) == 0: print 'adding a new buy all order' retval = self.add_buy_all_order() def run_buy_all(self): self.trade = 'buy' while self.trade == 'buy': now = datetime.datetime.now() print str(now) self.load_balances() self.load_order_book() print '%s Balance: %s' % (self.currency, self.total_currency_balance) print '%s Balance: %s' % (self.coin, self.total_coin_balance) self.buy_price = self.find_buy_price() print "Buy Price:", self.buy_price if self.total_currency_balance > self.min_currency_balance: print 'I have %s %s, will try to buy %s.' % ( self.total_currency_balance, self.currency, self.coin) self.trade = 'buy' else: print 'I have nothing to trade.' self.trade = False if self.trade == 'buy': self.buy_all() else: #Will not trade. Cancel all orders. self.cancel_open_orders('buy') self.cancel_open_orders('sell') print "." print "open orders:", self.open_orders print "." now = datetime.datetime.now() print str(now) print "Will wait a little bit for not to flood the exchange..." time.sleep(self.exchange_wait_time)
from poloniex import Poloniex import keyfile polo = Poloniex(keyfile.polokey, keyfile.polosecret) print(polo.returnTicker()['BTC_ETH']) print(keyfile.polokey) balance = polo.returnBalances() print("I have %s ETH" % balance['ETH'])
# Get private API keys apiKeyFile = open("POLONIEX_API_KEY", "r") apiKey = apiKeyFile.read() apiKeyFile.close() apiSecretFile = open("POLONIEX_SECRET", "r") apiSecret = apiSecretFile.read() apiSecretFile.close() #print(apiKey) #print(apiSecret) # Create private API link polo = Poloniex(apiKey, apiSecret) # Testing private API link feeInfo = polo.returnFeeInfo() print feeInfo #Testing ticker function ticker = polo.returnTicker()["USDT_BTC"] print ticker # Get BTC and USDT balances btcBalance = polo.returnBalances()["BTC"] usdtBalance = polo.returnBalances()["USDT"] print "BTC Balance is: ", btcBalance print "USDT Balance is: ", usdtBalance
def run(self, transaction=True): agent = Poloniex(self.apikey, self.secret) BTC2USD = Price().price('BTC', 'USD')['USD'] balance = agent.returnBalances() portfolio = {} for coin in self.coins: c_balance = balance[coin] if coin == 'BTC': portfolio[coin] = (BTC2USD, c_balance) else: portfolio[coin] = ( BTC2USD * agent.returnTicker()['BTC_{}'.format(coin)]['last'], c_balance) df = pd.DataFrame(portfolio, index=range(2)) df = df.append(df.ix[0] * df.ix[1], ignore_index=True) df = df.join( pd.Series(['/', '/', round(df.ix[2].sum(), 2)], name='total')) df = df.append(df.ix[2] / df.ix[2, -1], ignore_index=True) df.index = ['price', 'balance', 'value', 'weight'] df_str = df.round(2).replace( 0, '/').astype(str).apply(lambda s: s.str.rjust(8)) nbars = len(self.coins) * 10 + 17 print('#' * nbars) print('{:-^{width}}'.format(' CURRENT PORTFOLIO ({}) '.format( strftime('%Y-%m-%d %H:%M:%S', gmtime())), width=nbars)) print(df_str) self.train() print('{:-^{width}}'.format( ' SUGGESTED PORTFOLIO (EXP. SHARPE = {:.8f}) '.format(self.sharpe), width=nbars)) order = pd.DataFrame( [self.portfolio * df.ix[-2, -1] / df.ix[0, :-1], df.ix[1, :-1]], index=range(2)) order = order.append(order.ix[0, :] - order.ix[1, :], ignore_index=True) order.index = ['target', 'current', 'order'] print( order.round(3).replace( 0, '/').astype(str).apply(lambda s: s.str.rjust(8))) if transaction: print('{:-^{width}}'.format(' TRANSACTIONS ', width=nbars)) def mkt_order(coin, amount, slippage=.1): currencyPair = 'BTC_{}'.format(coin) ticker = agent.returnTicker() if amount: if amount > 0: rate = float(ticker[currencyPair]['lowestAsk']) * ( 1 + slippage) # in btc fee = rate * amount * 0.0025 # in btc print( '{} buy {:.3f} {} at {:.3f} USD/{}, fee = {:.6f} USD' .format(strftime('%Y-%m-%d %H:%M:%S', gmtime()), amount, coin, rate * BTC2USD, coin, fee * BTC2USD), end='') agent.buy(currencyPair=currencyPair, rate=rate, amount=amount, fillOrKill=1) elif amount < 0: rate = float(ticker[currencyPair]['highestBid']) * ( 1 - slippage) # in btc fee = -rate * amount * 0.0025 # in btc print( '{} sell {:.3f} {} at {:.3f} USD/{}, fee = {:.6f} USD' .format(strftime('%Y-%m-%d %H:%M:%S', gmtime()), -amount, coin, rate * BTC2USD, coin, fee * BTC2USD), end='') agent.sell(currencyPair=currencyPair, rate=rate, amount=-amount, fillOrKill=1) unset = order.ix[-1, np.setdiff1d(self.coins, ['BTC'])].sort_values() fail = 0 for coin in unset.index: try: amount = unset[coin] mkt_order(coin, amount) if amount: print('... succeed') except PoloniexCommandException: print('... fail (not enough fund)') fail += 1 fail += sum([ len(agent.returnOpenOrders(currencyPair='BTC_{}'.format(coin))) for coin in self.coins if not coin == 'BTC' ]) if fail: print('note: {} order(s) not successfully set'.format(fail)) balance = agent.returnBalances() portfolio = {} for coin in self.coins: c_balance = balance[coin] if coin == 'BTC': portfolio[coin] = (BTC2USD, c_balance) else: portfolio[coin] = ( BTC2USD * agent.returnTicker()['BTC_{}'.format(coin)]['last'], c_balance) df = pd.DataFrame(portfolio, index=range(2)) df = df.append(df.ix[0] * df.ix[1], ignore_index=True) df = df.join( pd.Series(['/', '/', round(df.ix[2].sum(), 2)], name='total')) df = df.append(df.ix[2] / df.ix[2, -1], ignore_index=True) df.index = ['price', 'balance', 'value', 'weight'] df_str = df.round(2).replace( 0, '/').astype(str).apply(lambda s: s.str.rjust(8)) print('{:-^{width}}'.format(' UPDATED PORTFOLIO ({}) '.format( strftime('%Y-%m-%d %H:%M:%S', gmtime())), width=nbars)) print(df_str) print('#' * nbars)
class Polo(Exchange): trade = False polon = 0 def __init__(self): self.polon = Poloniex() self.polon.key = config['polo']['key'] self.polon.secret = config['polo']['secret'] def get_exchange_name(self): return "Poloniex" def short_crypto(self, _crypto, _quantity, _price): symbol = "USDT_" + _crypto if trade: order = self.polon.sell(symbol, _price, _quantity) logger.info("Poloniex short " + _crypto + ". Quantity: " + Util.float_to_str(_quantity) + ", Price: " + str(_price)) def long_crypto(self, _crypto, _quantity, _price): symbol = "USDT_" + _crypto if trade: order = self.polon.buy(symbol, _price, _quantity) logger.info("Poloniex short " + _crypto + ". Quantity: " + Util.float_to_str(_quantity) + ", Price: " + str(_price)) def get_balances(self): balances = self.polon.returnBalances() non_zero_balances = {} for key, value in balances.items(): if float(value) > 0: non_zero_balances[key] = float(value) return non_zero_balances def get_balance_usd(self): balance = float(self.polon.returnTicker()['USDT_ETH']['last']) * float( self.polon.returnBalances()['ETH']) balance = balance + float(self.polon.returnTicker( )['USDT_DASH']['last']) * float(self.polon.returnBalances()['DASH']) balance = balance + float(self.polon.returnTicker()['USDT_ZEC']['last'] ) * float(self.polon.returnBalances()['ZEC']) balance = balance + float(self.polon.returnTicker()['USDT_BCH']['last'] ) * float(self.polon.returnBalances()['BCH']) balance = balance + float(self.polon.returnTicker()['USDT_BTC']['last'] ) * float(self.polon.returnBalances()['BTC']) balance = balance + float(self.polon.returnBalances()['USDT']) return balance def get_lowest_ask(self, _crypto): asks = self.polon.returnOrderBook()['USDT_' + _crypto]['asks'] lowestAsk = 10000000 for ask in asks: ask_price = float(ask[0]) if ask_price < lowestAsk: lowestAsk = ask_price return lowestAsk def get_highest_bid(self, _crypto): bids = self.polon.returnOrderBook()['USDT_' + _crypto]['bids'] highest_bid = 0 for bid in bids: bid_price = float(bid[0]) if bid_price > highest_bid: highest_bid = bid_price return highest_bid def get_make_fee(self): return 0.0015 def get_take_fee(self): return 0.0025
class LiveTrader: params = {"initial_depth": 4, "max_depth": 4, "variance_threshold": 0.00013, "band_threshold": 0.00013, "iteration_level": 3, "division_threshold": 0.00013, "max_weight": 8.0, "activation": "tanh"} # Config for CPPN. config = neat.config.Config(neat.genome.DefaultGenome, neat.reproduction.DefaultReproduction, neat.species.DefaultSpeciesSet, neat.stagnation.DefaultStagnation, 'config_trader') def __init__(self, ticker_len, target_percent, hd): self.polo = Poloniex(key, secret) self.hist_depth = hd self.target_percent = target_percent self.ticker_len = ticker_len self.end_ts = datetime.now()+timedelta(seconds=(ticker_len*55)) self.hs = HistWorker() self.refresh_data() self.tickers = self.polo.returnTicker() self.bal = self.polo.returnBalances() self.sellCoins() self.set_target() self.inputs = self.hs.hist_shaped.shape[0]*(self.hs.hist_shaped[0].shape[1]) self.outputs = self.hs.hist_shaped.shape[0] self.make_shapes() self.leaf_names = [] self.db = tinydb.database("live_hist/memories.json") for l in range(len(self.in_shapes[0])): self.leaf_names.append('leaf_one_'+str(l)) self.leaf_names.append('leaf_two_'+str(l)) #self.load_net() self.poloTrader() def load_net(self): #file = open("./champ_gens/thot-checkpoint-13",'rb') g = neat.Checkpointer.restore_checkpoint("./champ_gens/thot-checkpoint-25") best_fit = 0.0 for gx in g.population: if g.population[gx].fitness != None: if g.population[gx].fitness > best_fit: bestg = g.population[gx] g = bestg #file.close() [the_cppn] = create_cppn(g, self.config, self.leaf_names, ['cppn_out']) self.cppn = the_cppn def refresh_data(self): self.hs.pull_polo_live(20) self.hs.combine_live_frames(self.hist_depth) def make_shapes(self): self.in_shapes = [] self.out_shapes = [] sign = 1 for ix in range(1,self.outputs+1): sign = sign *-1 self.out_shapes.append((0.0-(sign*.005*ix), -1.0, -1.0)) for ix2 in range(1,(self.inputs//self.outputs)+1): self.in_shapes.append((0.0+(sign*.01*ix2), 0.0-(sign*.01*ix2), 1.0)) def get_one_bar_input_2d(self,end_idx=10): master_active = [] for x in range(0, self.hist_depth): active = [] #print(self.outputs) for y in range(0, self.outputs): sym_data = self.hs.hist_shaped[y][self.hist_depth-x] #print(len(sym_data)) active += sym_data.tolist() master_active.append(active) #print(active) return master_active def closeOrders(self): try: orders = self.polo.returnOpenOrders() except: print('error getting open orers') time.sleep(360) self.closeOrder() for o in orders: if orders[o] != []: try: ordnum = orders[o][0]['orderNumber'] self.polo.cancelOrder(ordnum) except: print('error closing') def sellCoins(self): for b in self.tickers: if(b[:3] == "BTC"): price = self.get_price(b) price = price - (price * .005) self.sell_coin(b, price) def buy_coin(self, coin, price): amt = self.target / price if(self.bal['BTC'] > self.target): self.polo.buy(coin, price, amt, fillOrKill=1) print("buying: ", coin) return def sell_coin(self, coin, price): amt = self.bal[coin[4:]] if (amt*price > .0001): try: self.polo.sell(coin, price, amt,fillOrKill=1) print("selling this shit: ", coin) except: print('error selling', coin) return def reset_tickers(self): try: self.tickers = self.polo.returnTicker() self.bal = self.polo.returnBalances() except: time.sleep(360) self.reset_tickers() return def get_price(self, coin): return self.tickers[coin]['last'] def set_target(self): total = 0 full_bal = self.polo.returnCompleteBalances() for x in full_bal: total += full_bal[x]["btcValue"] self.target = total*self.target_percent def poloTrader(self): end_prices = {} active = self.get_one_bar_input_2d() self.load_net() sub = Substrate(self.in_shapes, self.out_shapes) network = ESNetwork(sub, self.cppn, self.params) net = network.create_phenotype_network_nd('paper_net.png') net.reset() for n in range(1, self.hist_depth+1): out = net.activate(active[self.hist_depth-n]) #print(len(out)) rng = len(out) #rng = iter(shuffle(rng)) self.reset_tickers() for x in np.random.permutation(rng): sym = self.hs.coin_dict[x] #print(out[x]) try: if(out[x] < -.5): print("selling: ", sym) p = self.get_price('BTC_'+sym) price = p -(p*.01) self.sell_coin('BTC_'+sym, price) elif(out[x] > .5): print("buying: ", sym) self.target_percent = .1 + out[x] - .45 p = self.get_price('BTC_'+sym) price = p*1.01 self.buy_coin('BTC_'+sym, price) except: print('error', sym) #skip the hold case because we just dont buy or sell hehe if datetime.now() >= self.end_ts: return else: time.sleep(self.ticker_len) self.refresh_data() #self.closeOrders() self.poloTrader()
class LiveTrader: params = { "initial_depth": 0, "max_depth": 4, "variance_threshold": 0.03, "band_threshold": 0.3, "iteration_level": 1, "division_threshold": 0.3, "max_weight": 5.0, "activation": "tanh" } # Config for CPPN. config = neat.config.Config(neat.genome.DefaultGenome, neat.reproduction.DefaultReproduction, neat.species.DefaultSpeciesSet, neat.stagnation.DefaultStagnation, 'config_trader') def __init__(self, ticker_len, target_percent): self.polo = Poloniex(key, secret) self.currentHists = {} self.hist_shaped = {} self.coin_dict = {} self.ticker_len = ticker_len self.end_ts = datetime.now() + timedelta(seconds=(ticker_len * 55)) file = open("es_trade_god_cppn.pkl", 'rb') self.cppn = pickle.load(file) file.close() self.tickers = self.polo.returnTicker() self.bal = self.polo.returnBalances() self.target = self.bal['BTC'] * target_percent self.pull_polo() self.inputs = self.hist_shaped.shape[0] * ( self.hist_shaped[0].shape[1] - 1) self.outputs = self.hist_shaped.shape[0] self.multiplier = self.inputs / self.outputs def make_shapes(self): self.in_shapes = [] self.out_shapes = [] sign = 1 for ix in range(self.outputs): sign = sign * -1 self.out_shapes.append((sign * ix, 1)) for ix2 in range(len(self.hist_shaped[0][0]) - 1): self.in_shapes.append((sign * ix, (1 + ix2) * .1)) def pull_polo(self): tickLen = '7200' start = datetime.today() - timedelta(1) start = str(int(start.timestamp())) ix = 0 for coin in self.tickers: if coin[:3] == 'BTC': hist = requests.get( 'https://poloniex.com/public?command=returnChartData¤cyPair=' + coin + '&start=' + start + '&end=9999999999&period=' + tickLen) try: df = pd.DataFrame(hist.json()) #df.rename(columns = lambda x: col_prefix+'_'+x, inplace=True) as_array = np.array(df) #print(len(as_array)) self.currentHists[coin] = df self.hist_shaped[ix] = as_array self.coin_dict[ix] = coin ix += 1 except: print("error reading json") self.hist_shaped = pd.Series(self.hist_shaped) self.end_idx = len(self.hist_shaped[0]) - 1 def get_one_bar_input_2d(self): active = [] misses = 0 for x in range(0, self.outputs): try: sym_data = self.hist_shaped[x][self.end_idx] for i in range(len(sym_data)): if (i != 1): active.append(sym_data[i].tolist()) except: self.outputs -= 1 self.inputs -= self.multiplier print('error') #print(active) self.make_shapes() return active def closeOrders(self): orders = self.polo.returnOpenOrders() for o in orders: if orders[o] != []: try: ordnum = orders[o][0]['orderNumber'] self.polo.cancelOrder(ordnum) except: print('error closing') def sellCoins(self, coinlist, currency): balances = self.polo.returnBalances() for b in balances: bal = balances[b] * .99 def buy_coin(self, coin, price): amt = self.target if (self.bal['BTC'] > self.target): try: self.polo.buy(coin, price, amt, fillOrKill=1) print("buying: ", coin) except: print('error buying', coin) return def sell_coin(self, coin, price): amt = self.bal[coin[4:]] try: self.polo.sell(coin, price, amt, fillOrKill=1) except: print('error selling: ', coin) return def reset_tickers(self): self.tickers = self.polo.returnTicker() return def get_price(self, coin): return self.tickers[coin]['last'] def poloTrader(self): end_prices = {} active = self.get_one_bar_input_2d() sub = Substrate(self.in_shapes, self.out_shapes) network = ESNetwork(sub, self.cppn, self.params) net = network.create_phenotype_network() net.reset() for n in range(network.activations): out = net.activate(active) #print(len(out)) rng = len(out) #rng = iter(shuffle(rng)) for x in np.random.permutation(rng): sym = self.coin_dict[x] #print(out[x]) try: if (out[x] < -.5): print("selling: ", sym) self.sell_coin( sym, self.get_price(sym), ) elif (out[x] > .5): print("buying: ", sym) self.buy_coin(sym, self.get_price(sym)) except: print('error', sym) #skip the hold case because we just dont buy or sell hehe end_prices[sym] = self.get_price(sym) if datetime.now() >= self.end_ts: return else: time.sleep(self.ticker_len) self.reset_tickers self.pull_polo() self.poloTrader()