class TestPoloniexPrivateWithoutToken(unittest.TestCase): def setUp(self): self.poloniex = Poloniex('', '') def test_exception(self): with self.assertRaises(HTTPError): self.poloniex.returnBalances()
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)
class CoinList(object): def __init__(self): self._polo = Poloniex() #connect the internet to accees volumes vol = self._polo.marketVolume() pairs = [] coins = [] volumes = [] for k, v in vol.iteritems(): if k.startswith("BTC_") or k.endswith("_BTC"): pairs.append(k) for c, val in v.iteritems(): if c != 'BTC': coins.append(c) else: volumes.append(float(val)) self._df = pd.DataFrame({'coin': coins, 'pair': pairs, 'volume': volumes}) self._df = self._df.set_index('coin') @property def allActiveCoins(self): return self._df @property def allCoins(self): return self._polo.marketStatus().keys() @property def polo(self): return self._polo def topNVolume(self, n = 5, order = False, minVolume = 0): if minVolume == 0: r = self._df.sort_values(by='volume', ascending=False)[:n] if order: return r else: return r.sort_index() else: return self._df[self._df.volume >= minVolume]
def main(): """ Algorithm: If unused BTC: get min big loan offer Offer unused BTC at (min loan offer - 0.0001%) """ global DEBUG args = docopt(__doc__) if args['--debug']: DEBUG = True api_key = os.environ.get('POLONIEX_API_KEY') secret = os.environ.get('POLONIEX_SECRET') poloniex = Poloniex(api_key=api_key, secret=secret) unused_btc = poloniex.get_unused() if DEBUG: print "Unused BTC:", unused_btc if unused_btc: min_big_offer = poloniex.get_min_offer_rate(BTC_PER_BIG_OFFER) # Get 0.0001% below my_rate = min_big_offer - (0.0001 / 100) if DEBUG: print "poloniex.offer_btc_loan({}, {}, {})".format( my_rate, unused_btc, LOAN_DURATION) else: # Place the actual order order_id = poloniex.offer_btc_loan(my_rate, unused_btc, LOAN_DURATION) # Order status if order_id: print "Order placed ({})".format(order_id), else: print "Order failed", print "(Rate:", my_rate * 100, "%, Amount:", unused_btc, "BTC)"
class TestPoloniex(object): def setup(self): self.poloniex = Poloniex('', '') def test_ticker(self): res = self.poloniex.returnTicker() assert 'BTC_ETH' in res.keys() assert 'lowestAsk' in res['BTC_ETH'].keys() def test_volume(self): res = self.poloniex.return24hVolume() assert 'BTC_ETH' in res.keys() assert 'BTC' in res['BTC_ETH'].keys() def test_orderbook(self): res = self.poloniex.returnOrderBook('BTC_ETH') assert 'bids' in res.keys() assert 'asks' in res.keys() def test_tradehistory(self): start = datetime.now() - timedelta(hours=1) res = self.poloniex.returnTradeHistory('BTC_ETH', start) assert len(res) assert 'date' in res[0].keys() assert 'type' in res[0].keys() assert 'amount' in res[0].keys() assert 'rate' in res[0].keys() def test_chartdata(self): start = datetime.now() - timedelta(hours=1) res = self.poloniex.returnChartData('BTC_ETH', 300, start) assert len(res) assert 'date' in res[0].keys() assert 'volume' in res[0].keys() assert 'high' in res[0].keys() assert 'low' in res[0].keys() assert 'close' in res[0].keys()
def __init__(self, api=None): self.api = api if not self.api: self.api = Poloniex(jsonNums=float) self.db = MongoClient().poloniex['ticker'] self.db.drop() self.ws = websocket.WebSocketApp("wss://api2.poloniex.com/", on_message=self.on_message, on_error=self.on_error, on_close=self.on_close) self.ws.on_open = self.on_open
def main(): global DEBUG args = docopt(__doc__) if args['--debug']: DEBUG = True poloniex = Poloniex() max_demand = poloniex.get_max_demand_rate() min_offer = poloniex.get_min_offer_rate() min_big_offer = poloniex.get_min_offer_rate(BTC_PER_BIG_OFFER) print "max_demand:", max_demand, print "min_offer:", min_offer, print "min_big_offer:", min_big_offer if not DEBUG: keen.add_event("lending-rates", { "max-demand": max_demand, "min-offer": min_offer, "min-big-offer": min_big_offer })
def __init__(self, Key, Secret, interval=60*2, ageLimit=60*5, offset=2): """ - <Key> - Polo Api key - <Secret> - Polo Api secret - Loaner.INTERVAL = time in sec to wait between updates [default= 2min] - Loaner.AGELIMIT = max age (in sec) for an open loan offer [default= 5min] - Loaner.OFFSET = offset from the top loan offer rate (offset*0.000001) [default= 2] - Loaner.CHECKINT = number of times to check Loaner.RUNNING between intervals (could be hard on cpu if set too high and INTERVAL set too low!) [default= 20] - Loaner.MINAMOUNT = Minimum amount for creating loan offers [default= 0.01] """ self.POLO = Poloniex(Key, Secret) self.INTERVAL, self.AGELIMIT, self.OFFSET, self.CHECKINT, self.MINAMOUNT, self._running, self._thread = [interval, ageLimit, offset, 20, 0.01, False, None]
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
def __init__(self,base,quote): self.base = base self.quote = quote self.pair = self.base + '_' + self.quote self.price = Poloniex.getPrice(self,self.pair) Data.__init__(self) Charter.__init__(self) #Backtester.__init__(self) #xmr = FX("BTC","XMR") #xmr.saveChartData() #xmr.chartCandles('7D') #xmr.showChart()
def __init__(self): self.polo = Poloniex() vol = self.polo.marketVolume() pairs = [] coins = [] volumes = [] for k, v in vol.iteritems(): if k.startswith("BTC_") or k.endswith("_BTC"): pairs.append(k) for c, val in v.iteritems(): if c != 'BTC': coins.append(c) else: volumes.append(float(val)) self._df = pd.DataFrame({'coin': coins, 'pair': pairs, 'volume': volumes}) self._df = self._df.set_index('coin')
def getTickers(): from poloniex import Poloniex polo = Poloniex() ticker = polo.returnTicker() return ticker
#!/usr/bin/python3 from poloniex import Poloniex import operator import os import time import sys import secret import math p = Poloniex(*secret.token) delta = 0 priceMap = p.returnTicker() bar = '' res = 150 low = 0 rows = [] def point(num, char): point = int(res * (num - low) / delta) bar[point] = char for k, v in priceMap.items(): if k[0:3] == 'BTC': for i in ['low24hr', 'lowestAsk', 'last', 'highestBid', 'high24hr', 'baseVolume']: v[i] = float(v[i]) """ print("{:6} {} {} {} {} {} {}".format( k[4:], v['low24hr'], v['lowestAsk'], v['last'], v['highestBid'], v['high24hr'], v['baseVolume'] )) """
""" url = 'https://api.blockcypher.com/v1/eth/main/addrs/' + eth_address + '/balance' resp = requests.get(url) if resp.status_code != 200: print('Oops, something went wrong') data = resp.json() return (data['final_balance']) #initializing the classes nano = nano(eth_mining_address) bittrex = bittrex(bittrex_api_key["key"], bittrex_api_key["secret"]) polo = Poloniex() krak = krakenex.API() bc = bitchain() ec = ethchain() def calc_ETH_yields(hashrateMH): netHash = 6807 # network hash rate in GH/s blocktime = 12 # in seconds BlockReward = 5 # ETH userRatio = (hashrateMH * 1e6) / (netHash * 1e9) blocksPerMin = 60 / blocktime ETHPerMin = blocksPerMin * BlockReward # input or pulled off a website ETHPerMin = ETHPerMin * userRatio ETHPerHour = ETHPerMin * 60
class PoloniexExchange(ExchangeBaseClass): """ Class that manages Poloniex metadata. Inherits from alchemist_lib.exchange.exchange.ExchangeBaseClass. Website: https://poloniex.com/ Api documentation: https://poloniex.com/support/api/ Api wrapper: https://github.com/s4w3d0ff/python-poloniex Attributes: polo (poloniex.Poloniex): Communication object. """ def __init__(self): """ Costructor method. """ ExchangeBaseClass.__init__(self) self.polo = Poloniex() def get_min_order_size(self, asset): """ This method would return the minimum order size for a specific market, but It's not specified in the Poloniex documentation. https://poloniex.com/support/api/ Args: asset (alchemist_lib.database.asset.Asset): The asset traded again BTC. Return: size (decimal.Decimal): Minimum order size. Default is 0. """ return Decimal(0) def are_tradable(self, assets): """ Filters tradable assets. Args: assets (alchemist_lib.database.asset.Asset, list[Asset]): List of assets to check. Return: tradable (list[Asset]): Returns all tradable asset (remove not tradable assets from the arg). Note: Checks just pairs with BTC as base currency. """ assets = utils.to_list(assets) pairs = self.polo.returnTicker() tradable = [] for asset in assets: pair = "BTC_{}".format(asset.ticker) if pair in list(pairs.keys()): if pairs[pair]["isFrozen"] == "0": tradable.append(asset) else: logging.debug("{} is not tradable.".format(asset.ticker)) return tradable
class Polo(Base): """ Poloniex interface """ arg_parser = configargparse.get_argument_parser() arg_parser.add('--polo_api_key', help='Poloniex API key') arg_parser.add("--polo_secret", help='Poloniex secret key') 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): super(Polo, self).__init__() args = self.arg_parser.parse_known_args()[0] 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.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 get_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=300): """ 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_market_history(self, start, end, currency_pair='all'): """ Returns market trade history """ data = [] try: data = self.polo.marketTradeHist(currencyPair=currency_pair, start=start, end=end) except (PoloniexError, JSONDecodeError) as e: logger = logging.getLogger(__name__) logger.error('Got exception while retrieving polo data:' + str(e) + ', pair: ' + currency_pair, e) 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) 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
class wsTicker(object): def __init__(self, api=None): self.api = api if not self.api: self.api = Poloniex(jsonNums=float) self.db = MongoClient().poloniex['ticker'] self.db.drop() self.ws = websocket.WebSocketApp("wss://api2.poloniex.com/", on_message=self.on_message, on_error=self.on_error, on_close=self.on_close) self.ws.on_open = self.on_open def __call__(self, market=None): """ returns ticker from mongodb """ if market: return self.db.find_one({'_id': market}) return list(self.db.find()) def on_message(self, ws, message): message = json.loads(message) if 'error' in message: print(message['error']) return if message[0] == 1002: if message[1] == 1: print('Subscribed to ticker') return if message[1] == 0: print('Unsubscribed to ticker') return data = message[2] self.db.update_one( {"id": float(data[0])}, {"$set": {'last': data[1], 'lowestAsk': data[2], 'highestBid': data[3], 'percentChange': data[4], 'baseVolume': data[5], 'quoteVolume': data[6], 'isFrozen': data[7], 'high24hr': data[8], 'low24hr': data[9] }}, upsert=True) def on_error(self, ws, error): print(error) def on_close(self, ws): print("Websocket closed!") def on_open(self, ws): tick = self.api.returnTicker() for market in tick: self.db.update_one( {'_id': market}, {'$set': tick[market]}, upsert=True) print('Populated markets database with ticker data') self.ws.send(json.dumps({'command': 'subscribe', 'channel': 1002})) def start(self): self.t = Thread(target=self.ws.run_forever) self.t.daemon = True self.t.start() print('Thread started') def stop(self): self.ws.close() self.t.join() print('Thread joined')
class PoloniexClientWrapper: MAX_TRIES = 3 SLEEP_TRIES = 1 API_KEY = EXCHANGE_DATA["poloniex"]["api_key"] API_SECRET = EXCHANGE_DATA["poloniex"]["api_secret"] def __init__(self): self._client = Client(self.API_KEY, self.API_SECRET) self._cache = dict() def get_orderbook(self, symbol="BTC_USDT", limit=4612): operation = PoloniexOperation.GET_ORDERBOOK params = {"symbol": self._invert_symbol(symbol), "limit": limit} return self._request(operation, params) def get_orderbook_ticker(self, symbol="BTC_USDT"): operation = PoloniexOperation.GET_ORDERBOOK_TICKER params = {"symbol": self._invert_symbol(symbol)} return self._request(operation, params) def get_orderbook_tickers(self): operation = PoloniexOperation.GET_ORDERBOOK_TICKERS return self._request(operation) def get_recent_trades(self, symbol="BTC_USDT", limit=200): operation = PoloniexOperation.GET_RECENT_TRADES params = {"symbol": self._invert_symbol(symbol), "limit": limit} return self._request(operation, params) def get_coins(self): operation = PoloniexOperation.GET_COINS return self._request(operation) def _invert_symbol(self, symbol): coin_1, coin_2 = symbol.split("_") symbol = coin_2 + "_" + coin_1 return symbol def _request(self, operation, params=dict()): current_time = time.time() # Create cache key. key = str(operation) for p in params: key += str(params[p]) if key in self._cache and \ abs(current_time - self._cache[key]["time"]) < 60: return self._cache[key]["database"] else: i = 0 while i < self.MAX_TRIES: try: if operation == PoloniexOperation.GET_ORDERBOOK: response = self._client.returnOrderBook( currencyPair=params["symbol"], depth=params["limit"]) elif operation == PoloniexOperation.GET_ORDERBOOK_TICKER: response = self._client.returnOrderBook( currencyPair=params["symbol"], depth=1) elif operation == PoloniexOperation.GET_ORDERBOOK_TICKERS: response = self._client.returnOrderBook( currencyPair="all", depth=1) elif operation == PoloniexOperation.GET_RECENT_TRADES: response = self._client.returnTradeHistoryPublic( currencyPair=params["symbol"])[:params["limit"]] elif operation == PoloniexOperation.GET_COINS: response = self._client._private('returnBalances') break except Exception as e: print(e) if i < self.MAX_TRIES: time.sleep(self.SLEEP_TRIES) self._client = Client(self.API_KEY, self.API_SECRET) current_time = time.time() i += 1 else: return None if key not in self._cache: self._cache[key] = dict() # Update cache. self._cache[key]["time"] = current_time self._cache[key]["database"] = response return response
def __init__(self, api_key, secret): api_p='' key_p='' self.api=Poloniex(api_key, secret) pass
import gdax from poloniex import Poloniex import pandas as pd #### Polo Data polo = Poloniex() orders = polo.returnOrderBook()['BTC_ETH'] poloAsks = pd.DataFrame(orders['asks']) poloAsks.columns = ['price', 'volume'] poloAsks = poloAsks.astype(float) poloBids = pd.DataFrame(orders['bids']) poloBids.columns = ['price', 'volume'] poloBids = poloBids.astype(float) #### GDAX Data public_client = gdax.PublicClient() wsClient = gdax.WebsocketClient(url="wss://ws-feed.gdax.com", products="ETH-BTC") gdaxEthBtcOrderBook = public_client.get_product_order_book('ETH-BTC', level=2) bids = dict.get(gdaxEthBtcOrderBook, 'bids') asks = dict.get(gdaxEthBtcOrderBook, 'asks') wsClient.close() gdaxBids = pd.DataFrame(bids) gdaxBids.columns = ["price", "volume", "orders"] gdaxBids = gdaxBids.astype(float)
# Import Standard Library Modules import time import sys # Import the External Poloniex Library (python-poloniex-master folder + PIP install poloniex) import poloniex from poloniex import Poloniex try: # First check for user BTC Value input budget = str(sys.argv[1]) #.format('0.001') except: # Print an Exeption (error) if there is no input print("put Budget in as python AllCoinsInBTC.py 0.001") exit(1) while True: # Setup to connect to Poloniex API try: polo = Poloniex() polo.key = 'Your_Poloniex_Key_Here' polo.secret = 'Your_Poloniex_Secret_Here' print(" ") print("---!Connected to Poloniex.com!---") break except: backoff("Can not connect to Poloniex API") exit(1) def backoff(msg): # Function for the Error Message later in script print(msg) time.sleep(0.1)
from ConfigParser import SafeConfigParser # get config config = SafeConfigParser() config_location = 'default.cfg' loadedFiles = config.read([config_location]) duration = float(config.get("BOT", "duration")) frequency = int(config.get("BOT", "frequency")) total_amount_to_spend = float(config.get("BOT", "totalAmountToSpend")) api_key = config.get("API","apikey") api_secret = config.get("API","secret") currency_pair = "BTC_XMR" # initiate bot bot = Poloniex(api_key, api_secret) # variables btc_volume_each_trade = total_amount_to_spend/(duration*3600/frequency) amount_traded_in_btc = 0.0 amount_xmr_bought = 0.0 # see how far we have to go into the order book to fill the order def get_buy_price(): order_book = bot.returnOrderBook(currency_pair) asks = order_book["asks"] btc_ask_volume = 0.0 for i, val in enumerate(asks): btc_ask_volume += (float(val[0]) * val[1]) if btc_ask_volume >= btc_volume_each_trade: return float(val[0])
def setUp(self): self.poloniex = Poloniex('BTC_BTS', 60)
def test_invalid_currency(self): self.instance = Poloniex('TC_DASH', 800) self.assertNotIn(self.instance.currency_pair, self.instance._list_currencies())
from poloniex import Poloniex from sklearn.linear_model import LinearRegression import helper_functions as hf import matplotlib.pyplot as plt from sklearn.model_selection import train_test_split # define the currency pair we will be performing with currency_pair = ['BTC_ETH'] # retrieve the crypto-currency chart data chart_data = hf.glueCurrencies(currency_pair, Poloniex()) # create a Poloniex api model according to the given currency pairs polo_model = hf.create_poloniex_model(chart_data) # create the needed parameters for the linear regression model and its prediction methods processed_model, predict, x_test, y_test = hf.poloniex_linear_regression( polo_model, LinearRegression()).values() # draw the linear regression prediction line and print the next estimated price for the mentioned unix time period hf.draw_prediction(predict, processed_model, x_test, y_test)
def __init__(self): self._client = Client(self.API_KEY, self.API_SECRET) self._cache = dict()
def setup(self): self.poloniex = Poloniex('', '')
import pandas as pd from bokeh.plotting import figure, output_file, show import numpy as np from sklearn import linear_model from bokeh.models import HoverTool, BoxSelectTool import matplotlib.pyplot as plt import datetime as dt from pandas_datareader import data #change the number to move the left bound left and right if needed numOfDaysToGet = 17000 numOfCandleSticksToPredict = 1 currencyToGet = 'USDT_BTC' windowLength = 14 #api call with poloniex api = Poloniex(timeout=None, jsonNums=float) #change the number to move the right bound left and right if needed NumOfDaysToMoveBackFromToday = time() - api.DAY*0 #period of candlesticks to recieve: 24, 4, 2, 0.5, 0.25, or 0.083 period = api.HOUR * 24 #api call raw = api.returnChartData(currencyToGet, period=period, start=time() - api.DAY*numOfDaysToGet, end= NumOfDaysToMoveBackFromToday) #load dataframe with infrom from api call df = pd.DataFrame(raw) #create date column and convert epoch time from api call to date
from poloniex import Poloniex from decimal import Decimal import time import datetime from config import * polo = Poloniex(API_KEY, SECRET) def main(): # for each coin, create a specific coin seller global polo coin_sellers = [CoinSeller(config) for config in sell_coin_configs] while True: for coin_seller in coin_sellers: try: coin_seller.sell() except Exception as e: print(e) print( '\033[91m{} error when selling {}. recreate polo.\033[0m'. format( datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), coin_seller.coin)) polo = Poloniex(API_KEY, SECRET) time.sleep(SLEEP_TIME) class CoinSeller:
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)
def stringMaker(inpair): #returns a tuple --> (text, colour) polo=Poloniex() ticker = polo.returnTicker()[inpair] print "~~~Running stringMaker(string_pair) function~~~" last_val = ticker['last'] disp_last_val = last_val prefix = "" # For BTC pairs, this makes things more readable if inpair[0:3] == "BTC": pair1_disp = (inpair[0:3] + "/" +inpair[4:]) #print inpair,"--> is a BTC Pair" if last_val < 0.001: disp_last_val = str(last_val/(1e-6)) prefix = u"\u00B5\u20BF " #print "uB" + disp_last_val elif last_val < 0.01: disp_last_val = str(int(last_val/(1e-6))) prefix = u"\u00B5\u20BF " #print "uB " + disp_last_val elif last_val < 1: disp_last_val = str(round(last_val,5)) prefix = u"\u20BF " #print "B" + disp_last_val # For USDT pairs, this makes thigs more readable if inpair[0:4] == "USDT": pair1_disp = (inpair[0:4] + "/" +inpair[5:]) prefix = "$" #print inpair,"--> is a USDT Pair" count = 0 number = last_val while (number > 0): number = number//10 count = count + 1 if last_val < 1: disp_last_val = "Less than $1" #print disp_last_val elif count > 3: disp_last_val = str(int(round(last_val))) #print "$" + disp_last_val elif count >= 1: disp_last_val = '%.2f'%last_val #print "$" + '%.2f'%last_val #print inpair #print"Last Value:", last_val percent_change = ticker['percentChange'] percent_change = percent_change*100 #print "Percent Change:", round(percent_change,2), "%" neg = 1 #change this to something orange if percent_change < 0: colour = "255,0,0" neg = (255,0,0) #red else: colour = "0,255,0" neg = (0,255,0) #green pc = str(round(percent_change,1)) coin_display_string = pair1_disp + " " + prefix + str(disp_last_val) + " " + pc + "% " print coin_display_string return (coin_display_string, neg)
class Loaner(object): """ Object for control of threaded Loaner loop""" def __init__(self, Key, Secret, interval=60*2, ageLimit=60*5, offset=2): """ - <Key> - Polo Api key - <Secret> - Polo Api secret - Loaner.INTERVAL = time in sec to wait between updates [default= 2min] - Loaner.AGELIMIT = max age (in sec) for an open loan offer [default= 5min] - Loaner.OFFSET = offset from the top loan offer rate (offset*0.000001) [default= 2] - Loaner.CHECKINT = number of times to check Loaner.RUNNING between intervals (could be hard on cpu if set too high and INTERVAL set too low!) [default= 20] - Loaner.MINAMOUNT = Minimum amount for creating loan offers [default= 0.01] """ self.POLO = Poloniex(Key, Secret) self.INTERVAL, self.AGELIMIT, self.OFFSET, self.CHECKINT, self.MINAMOUNT, self._running, self._thread = [interval, ageLimit, offset, 20, 0.01, False, None] def _run(self): """ Main loop that is threaded (set Loaner.RUNNING to 'False' to stop loop)""" while self._running: try: self.cancelOldLoans(self.POLO.myOpenLoanOrders(), self.AGELIMIT) self.createLoans(self.POLO.myAvailBalances(), self.OFFSET) for i in range(self.CHECKINT): if not self._running: break time.sleep(self.INTERVAL/self.CHECKINT) except Exception as e: logging.info(e);time.sleep(self.INTERVAL/self.CHECKINT) def start(self): """ Start Loaner.thread""" self._thread = Thread(target=self._run);self._thread.daemon = True self._running = True;self._thread.start() logging.info('LOANER: started') def stop(self): """ Stop Loaner.thread""" self._running = False;self._thread.join() logging.info('LOANER: stopped') def cancelOldLoans(self, orderList, ageLimit): """ Cancel loans in <orderList> that are older than <ageLimit> - orderList = JSON object received from poloniex (open loan orders) - ageLimit = max age to allow an order to sit still before canceling (in seconds)""" logging.info('LOANER: Checking for stale offers') for market in orderList: for order in orderList[market]: logging.info('LOANER: %s order %s has been open %f2 mins' % (market, str(order['id']), round((time.time()-self.POLO.UTCstr2epoch(order['date']))/60, 2))) if time.time()-self.POLO.UTCstr2epoch(order['date']) > ageLimit: result = self.POLO.cancelLoanOrder(order['id']) if not 'error' in result: logging.info('LOANER: %s %s [%s]' % (market, result["message"].lower(), str(order['id']))) else: logging.info('LOANER: %s' % result['error']) def createLoans(self, balances, offset): """ Create loans for all markets in <balances> at the <offset> from the top rate - balances = JSON object received from poloniex (available balances) - offset = number of 'loanToshis' to offset from the top loan order (offset*0.000001)""" if 'lending' in balances: logging.info('LOANER: Checking for coins in lending account') for market in balances['lending']: if float(balances['lending'][market]) > self.MINAMOUNT: result = self.POLO.createLoanOrder(market, balances['lending'][market], float(self.POLO.marketLoans(market)['offers'][0]['rate'])+(offset*0.000001)) if not 'error' in result: logging.info('LOANER: %s %s %s' % (balances['lending'][market], market, result["message"].lower())) else: logging.info('LOANER: %s' % result['error'])