class Bittrex_Adapter(Market_Adapter): def __init__(self): auth = util.get_bittrex_auth() self.bitt = Bittrex(auth["key"], auth["secret"], api_version=API_V2_0) self.timeout = 90 self.retries = 5 def buy_by_symbol(self, symbol, total): pair = "BTC-{}".format(symbol) self.bitt.trade_buy(market=pair, order_type="LIMIT") def get_btc(self): val = self.bitt.get_balance("BTC")["result"] if val is None: return 0.0 return val def get_highest_bid(self, symbol): pair = "BTC-{}".format(symbol) ticker = self.bitt.get_orderbook(pair)["result"]["buy"] # print(ticker) return float(ticker[0]["Rate"]) def get_lowest_ask(self, symbol): pair = "BTC-{}".format(symbol) candle = self.bitt.get_latest_candle(pair, TICKINTERVAL_ONEMIN) print(candle)
def set_buy_point(market_, price, money, price_offset_factor = 0.99): from bittrex.bittrex import Bittrex, API_V1_1, API_V2_0 API_V20 = Bittrex('','',api_version=API_V2_0) API_V11 = Bittrex('','',api_version=API_V1_1) # place a buy order, price could be lower than macd price buy_price = price*price_offset_factor buy_amount = money/buy_price while(1): text = '>>>>>>>>>>>' + market_ + ": place a buy order of amount of" + str(buy_amount) + "@$" + str(buy_price) print(text) # place order(market_, price, amount) # check respond # take care of double order if (1): break # leave a record buy_set_info = dict() buy_set_info['market_'] = market_ buy_set_info['price'] = buy_price buy_set_info['amount'] = buy_amount buy_set_info['activity'] = 'buy_set' buy_set_info['time'] = API_V11.get_marketsummary(market='USDT-OMG')['result'][0]['TimeStamp'] return buy_set_info
def __init__(self): """ Costructor method. """ ExchangeBaseClass.__init__(self) self.bittrex = Bittrex(api_key=None, api_secret=None)
class TestBittrexPublicAPI(unittest.TestCase): """ Integration tests for the Bittrex public API. These will fail in the absence of an internet connection or if bittrex API goes down """ def setUp(self): self.bittrex = Bittrex(None, None) def test_handles_none_key_or_secret(self): self.bittrex = Bittrex(None, None) # could call any public method here actual = self.bittrex.get_markets() self.assertTrue(actual['success'], "failed with None key and None secret") self.bittrex = Bittrex("123", None) actual = self.bittrex.get_markets() self.assertTrue(actual['success'], "failed with None secret") self.bittrex = Bittrex(None, "123") self.assertTrue(actual['success'], "failed with None key") def test_get_markets(self): actual = self.bittrex.get_markets() test_basic_response(self, actual, "get_markets") self.assertTrue(isinstance(actual['result'], list), "result is not a list") self.assertTrue(len(actual['result']) > 0, "result list is 0-length") def test_get_currencies(self): actual = self.bittrex.get_currencies() test_basic_response(self, actual, "get_currencies") pass
class Bittrex_Interface(Exchange_Interface): ''' Bittrex Interface ''' def __init__(self, key): self.use_key(key) self.connection = Bittrex(self.get_key_str(), self.get_key_secret(), api_version=API_V2_0) def get_balance(self): response = self.connection.get_balances()['result'] balances = {} for record in response: balance = record['Balance']['Balance'] currency = record['Currency']['Currency'] if balance > 0.0: balances[currency] = balance return balances def update_candles(self, logger): candle_sticks.update_bittrex(logger, self.connection) def get_ticker_prices(self, base_name, pair_names): ticker_prices = {} for pair_name in pair_names: latest_candle = self.connection.get_latest_candle( base_name + '-' + pair_name, TICKINTERVAL_HOUR)['result'][0] ticker_prices[pair_name] = float(latest_candle['C']) return ticker_prices
def getData(mercado, intervalo, bot, update, evento1, evento2): evento1.acquire() print("Empieza hilo 1") global contador1 try: texto = "[" + str( contador1 ) + "] ACTUALIZANDO EXCEL DE " + mercado + " CON INTERVALO " + intervalo bot.send_message(chat_id=update.message.chat_id, text=texto) except telegram.error.TimedOut: print("Ha habido un error enviando mensaje en getData") contador1 += 1 my_bittrex = Bittrex(None, None, api_version=API_V2_0) data = my_bittrex.get_candles(mercado, intervalo) """ data["result"] para limpiar los datos anteriores a result """ df = pd.DataFrame(data["result"]) df = df.rename(index=str, columns={ "BV": 'basevolume', "C": 'close', "H": 'high', "L": 'low', "O": 'open', "T": 'date', "V": '24hvolume' }) df.to_excel("data/" + mercado + ".xlsx") evento2.release() print("Se da paso a hilo 2")
def setUp(self): with open("secrets.json") as secrets_file: self.secrets = json.load(secrets_file) secrets_file.close() self.bittrex = Bittrex(self.secrets['key'], self.secrets['secret'], api_version=API_V2_0)
def __init__(self, config: dict): """ Initializes the ApiWrapper with the given config, it does basic validation whether the specified exchange and pairs are valid. :param config: dict """ self.dry_run = config['dry_run'] if self.dry_run: logger.info('Instance is running with dry_run enabled') use_poloniex = config.get('poloniex', {}).get('enabled', False) use_bittrex = config.get('bittrex', {}).get('enabled', False) if use_poloniex: self.exchange = Exchange.POLONIEX self.api = Poloniex(key=config['poloniex']['key'], secret=config['poloniex']['secret']) elif use_bittrex: self.exchange = Exchange.BITTREX self.api = Bittrex(api_key=config['bittrex']['key'], api_secret=config['bittrex']['secret']) else: self.api = None raise RuntimeError('No exchange specified. Aborting!') # Check if all pairs are available markets = self.get_markets() for pair in config[self.exchange.name.lower()]['pair_whitelist']: if pair not in markets: raise RuntimeError( 'Pair {} is not available at Poloniex'.format(pair))
def test_handles_invalid_key_or_secret(self): self.bittrex = Bittrex('invalidkey', self.secrets['secret'], api_version=API_V2_0) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'Invalid key, valid secret') self.bittrex = Bittrex(None, self.secrets['secret'], api_version=API_V2_0) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'None key, valid secret') self.bittrex = Bittrex(self.secrets['key'], 'invalidsecret', api_version=API_V2_0) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'valid key, invalid secret') self.bittrex = Bittrex(self.secrets['key'], None, api_version=API_V2_0) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'valid key, None secret') self.bittrex = Bittrex('invalidkey', 'invalidsecret', api_version=API_V2_0) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'invalid key, invalid secret')
def scrape(chunk=1, ticker_interval=TICKINTERVAL_HOUR): producer = KafkaProducer(bootstrap_servers=rose_host) for coin in coins[(chunk - 1) * 10:chunk * 10]: market = 'BTC-' + coin["symbol"] if coin["symbol"] == 'BTC': market = 'USDT-' + coin["symbol"] bittrex = Bittrex(os.environ['CRYPTOEYES_KEY'], os.environ['CRYPTOEYES_SEC']) bittrexv2 = Bittrex(os.environ['CRYPTOEYES_KEY'], os.environ['CRYPTOEYES_SEC'], api_version=API_V2_0) # histories = bittrex.get_market_history(market) if last == "True": candles = bittrexv2.get_latest_candle(market, ticker_interval) else: candles = bittrexv2.get_candles(market, ticker_interval) if candles.get("success") == True and candles.get( "result") is not None: topic = 'bittrex.' + market + '.candle.' + ticker_interval + '.' + partition for can in candles["result"]: producer.send(topic, json.dumps(can).encode()) else: print(market, candles) print("there're " + str(len(coins)) + " of coins are tracking.")
def control(): my_bittrex = Bittrex(None, None, api_version=API_V2_0) data=my_bittrex.get_market_summaries() btcCount=0 ethCount=0 usdtCount=0 for i in range(0,len(data['result'])): if data['result'][i]['Summary']['MarketName'][0:4]=="BTC-": btc_fmarket=data['result'][i]['Summary']['MarketName'] btc_coinname=btc_fmarket[4:len(btc_fmarket)] query_btc=Coin.objects.filter(koin_name=btc_coinname) if len(query_btc)==0: Coin.objects.create(koin_name=btc_coinname) btcCount+=1 elif data['result'][i]['Summary']['MarketName'][0:4]=="ETH-": eth_fmarket=data['result'][i]['Summary']['MarketName'] eth_coinname=eth_fmarket[4:len(eth_fmarket)] query_eth=Coin.objects.filter(koin_name=eth_coinname) if len(query_eth)==0: Coin.objects.create(koin_name=eth_coinname) ethCount+=1 if data['result'][i]['Summary']['MarketName'][0:5]=="USDT-": usdt_fmarket=data['result'][i]['Summary']['MarketName'] usdt_coinname=usdt_fmarket[5:len(usdt_fmarket)] query_usdt=Coin.objects.filter(koin_name=usdt_coinname) if len(query_usdt)==0: Coin.objects.create(koin_name=usdt_coinname) usdtCount+=1 print(btcCount,"btc") print(ethCount,"eth") print(usdtCount,"usd")
def GetInformations(self, MarketName): BittRexCo = Bittrex(None, None) Data = BittRexCo.get_markets() if Data['success']: Res = Data['result'] for item in Res: if item['MarketName'] == MarketName: self.MarketName = item['MarketName'] self.MarketCurrency.GetInformation(item['MarketCurrency']) self.BaseCurrency.GetInformation(item['BaseCurrency']) self.MinTradeSize = item['MinTradeSize'] self.IsActive = item['IsActive'] self.Created = item['Created'] Data2 = BittRexCo.get_marketsummary(item['MarketName']) if Data2['success']: for item2 in Data2['result']: self.High = item2['High'] self.Low = item2['Low'] self.Last = item2['Last'] self.Volume = item2['Volume'] self.BaseVolume = item2['BaseVolume'] self.TimeStamp = item2['TimeStamp'] self.Bid = item2['Bid'] self.Ask = item2['Ask'] self.OpenSellOrders = item2['OpenSellOrders'] self.OpenBuyOrders = item2['OpenBuyOrders'] self.PrevDay = item2['PrevDay'] return True return False
def get_post(self, post): if not post.author or post.author != self.author: return kwargs = {'author': post.author, 'permlink': post.slug} try: blockchain_post = Post(post=kwargs, steemd_instance=self.steem) except: return votes = blockchain_post.get( 'net_votes') # len(post.get('active_votes')) post.votes = votes # pending reward reward_pending_amount = blockchain_post.get( 'total_pending_payout_value') amount = reward_pending_amount.get('amount') asset = reward_pending_amount.get('asset') if amount > 0: post.reward = amount self.set_asset(post, asset) # payouts reward total_payout_value = blockchain_post.get('total_payout_value') amount = total_payout_value.get('amount') asset = total_payout_value.get('asset') self.set_asset(post, asset) if amount > 0: post.reward = amount post.complete = True if not post.reward: post.save() return if post.provider == 'golos': # calc BTC local_course = self.get_local_course() if local_course: base_course = local_course.get('base') if base_course: gbg_course = float(base_course.split(' ')[0]) gbg_golos = post.reward / gbg_course api = Bittrex(settings.BITTREX_KEY, settings.BITTREX_SECRET) btc_cost = api.get_ticker('BTC-GOLOS').get('result').get( 'Ask') post.btc = btc_cost * gbg_golos # calc RUB reward rub_course = Coinapult().get_current_price(currency='RUB') post.rub = post.btc * float(rub_course) else: return # TODO set it for steem post.save()
def PlaceSellOrder(self, market, quantity, rate): BittRexCo = Bittrex(self.apikey, self.apisecret) Data = BittRexCo.sell_limit(market, quantity, rate) if not Data['success']: print(Data['message']) return Data['success']
def __init__(self, key, secret): self.__apiKey = key self.__apiSecret = secret self.__apiVersion = API_V1_1 self.__bittrex = Bittrex(self.__apiKey, self.__apiSecret, api_version=self.__apiVersion)
def __init__(self, config, verbosity=2): super(BittrexClient, self).__init__() api_key = config['api_key'] secret = config['secret'] self.transaction_fee = float(config['transaction_fee']) self.bittrex = Bittrex(api_key, secret) self.pair_delimiter = '-' self.verbosity = verbosity
def login(*args): try: # value = apikey.get() bittrex = Bittrex(apikey.get(), apisecret.get()) print(bittrex.get_balances()) # meters.set((0.3048 * value * 10000.0 + 0.5) / 10000.0) except ValueError: pass
def Test(key, secret, market, coinname): # threading.Timer(10, Test, args=(key, secret, market, coinname)).start() TestTrading = Bittrex(key, secret) t = TestTrading.get_ticker(market) #balance = TestTrading.get_balance(coinname) bid = t['result']['Bid'] print("| Bid | {: .8f} ".format(bid)) return bid
def __init__(self): self._client = Bittrex(api_key=os.getenv('bittrex_api_key'), api_secret=os.getenv('bittrex_api_secret')) r = self._client.get_balances() if not r.get('success'): if r.get('message') == 'APIKEY_INVALID': raise Exception('Invalid API Keys') raise Exception('Error: ' + r.get('message'))
def bittrex(market='BTC-XLM'): global API bittrex = Bittrex(None, None, api_version=API) ticket_bittrex = bittrex.get_ticker(market)['result'] print("Ask : " + FORMAT.format(ticket_bittrex['Ask']) + " Bid : " + FORMAT.format(ticket_bittrex['Bid'])) ask_Bittrex = ticket_bittrex['Ask'] bid_Bittrex = ticket_bittrex['Bid'] return ask_Bittrex, bid_Bittrex
def __init__(self): args = self.arg_parser.parse_known_args()[0] super(BittrexClient, self).__init__() api_key = args.bittrex_api_key secret = args.bittrex_secret self.transaction_fee = float(args.bittrex_txn_fee) self.bittrex = Bittrex(api_key, secret) self.pair_delimiter = '-' self.verbosity = args.verbosity
def TradingAlorythm(command, market, amount, coinname, step, stoploss, key, secret): TestTrading = Bittrex(key, secret) period = timedelta(seconds=20) next_tick = datetime.now() + period seconds = 20 firstCycle = True if command == "y": print("buying {0} of {1} coins".format(amount, coinname)) # раскомментировать для созадния ордера на покупку # TestTrading.buy_limit(market, amount, coinprice) while command == "y": # таймер каждые 20 секунд if next_tick <= datetime.now(): print("Connecting to Bittrex") seconds += 20 next_tick += period print("Timer ticked") print("Updating stock exchange...") # Считываем значения курса t = TestTrading.get_ticker(market) # Запрашиваем баланс balance = TestTrading.get_balance(coinname) # Запрашиваем текущие ордера orders = TestTrading.get_open_orders(market) a = json.dumps(t) # Печатаем значения курса print(t) # Печатаем баланс print("Balance is {} ".format(balance['result']['Available'])) # Печатаем ордера print(orders) # Раскладываем по переменным bid = t['result']['Bid'] ask = t['result']['Ask'] last = t['result']['Last'] if firstCycle: StartValue = bid firstCycle = False Stop_loss = StartValue - 0.00000007 print("*--------------------------") print("| Start Value | {: .8f} ".format(StartValue)) print("| Stop loss | {: .8f} ".format(Stop_loss)) print("|--------------------------") print("| Bid | {: .8f} ".format(bid)) print("| Ask | {: .8f} ".format(ask)) print("| Last | {: .8f} ".format(last)) print("*--------------------------") # Добавляем Bid в конец массива # A.append(float(bid)) if bid >= step + StartValue: print("MOVE STOP-LOSS") StartValue = bid if bid <= stoploss: print("Sell order sent")
def __init__(self, auth=False): if auth: with open('bittrex.key') as kfile: api_key = kfile.readline().strip() api_secret = kfile.readline().strip() else: api_key = None api_secret = None self.conn = Bittrex(api_key, api_secret, api_version=API_V2_0)
def __init__(self, bot): self.bot = bot self.my_bittrex = Bittrex("", "", api_version=API_V2_0) self.settings = fileIO("data/cryptocoin/settings.json", "load") self.data15min = fileIO("data/cryptocoin/data15min.json", "load") self.data30min = fileIO("data/cryptocoin/data30min.json", "load") self.data1hour = fileIO("data/cryptocoin/data1hour.json", "load") self.data4hour = fileIO("data/cryptocoin/data4hour.json", "load") self.data12hour = fileIO("data/cryptocoin/data12hour.json", "load") self.data1day = fileIO("data/cryptocoin/data1day.json", "load")
def __init__(self, **kwargs): api_key = kwargs["api_key"] api_secret = kwargs["api_secret"] if not all([api_key, api_secret]): raise Exception( f"Both api_key and api_secret are required for {name} exchange") self.client = Bittrex(api_key, api_secret, API_V1_1) self.debug_mode = environ.get("DEBUG", False)
def __init__(self, marketPair, riskPercent): self.client = Bittrex(API_KEY, API_SECRET) self.marketPair = marketPair self.riskPercent = riskPercent self.tickerData = self.client.get_ticker(marketPair) self.currentPrice = self.tickerData.get('result').get('Last') self.highPrice = self.currentPrice self.priceDifference = 0 self.limitPrice = round((self.currentPrice * (1 - self.riskPercent)), 8)
class BittrexUtils: def __init__(self): self.my_bittrex = Bittrex(BITTREX_KEY, BITTREX_SECRET) def get_available_balance(self, symbol): return self.my_bittrex.get_balance(symbol)["result"]["Available"] def get_ask(self, symbol): """Return current ask price for symbol""" pair = f'BTC-{symbol}' return self.my_bittrex.get_marketsummary(pair)["result"][0]["Ask"] def get_bid(self, symbol): """Return current bid price for symbol""" pair = f'BTC-{symbol}' return self.my_bittrex.get_marketsummary(pair)["result"][0]["Bid"] def get_last(self, symbol): """Return current last price for symbol""" pair = f'BTC-{symbol}' return self.my_bittrex.get_marketsummary(pair)["result"][0]["Last"] def prepare_btc_buy(self, symbol, amount): """Prepare get pair, quantity and price for create_buy_order""" pair = f'BTC-{symbol}' price = self.get_ask(symbol) * 1.02 # Buy 2% higher quantity = round(amount / price, 8) return pair, quantity, price def create_buy_order(self, pair, quantity, price): """Create buy order on Bittrex, return order uuid""" response = self.my_bittrex.buy_limit(pair, quantity, price) if response["success"]: return response["result"]["uuid"] else: raise Exception(response["message"]) def create_sell_order(self, pair, quantity, price): """Create sell order on Bittrex, return order uuid""" response = self.my_bittrex.sell_limit(pair, quantity, price) if response["success"]: return response["result"]["uuid"] else: raise Exception(response["message"]) def get_open_orders(self): orders = self.my_bittrex.get_open_orders()["result"] result = [] for order in orders: message = f'Order {order["OrderUuid"]}\n\n{order["Exchange"]}\nType: {order["OrderType"]}\nQuantity: {order["Quantity"]}\nPrice: {order["Limit"]}\nBTC total: {order["Limit"]*order["Quantity"]}\n\nOpen: {order["Closed"] == None}' result.append(message) return result def cancel_order(self, uuid): return self.my_bittrex.cancel(uuid)["success"] def get_order_status(self, uuid): """Returns string of order status""" order = self.my_bittrex.get_order(uuid)["result"] return f'Order {order["OrderUuid"]}\n\n{order["Exchange"]}\nType: {order["Type"]}\nQuantity: {order["Quantity"]}\nPrice: {order["Limit"]}\nBTC total: {order["Reserved"]}\n\nOpen: {order["IsOpen"]}'
def get_bittrex(key, secret): """Get balance from bittrex exchange API.""" my_bittrex = Bittrex(key, secret, api_version=API_V2_0) balances = my_bittrex.get_balances() df = pd.DataFrame([row['Balance'] for row in balances['result']]) df = df[['Balance', 'Currency']] df['source'] = 'bttrex' df.columns = ['balance', 'coin', 'source'] return df
def bittrex_list_markets_by_currency(chat_id, cur): full_api = getbittrexapi(chat_id)['bittrex_api'] api_key = full_api.split(':')[0].strip() api_secret = full_api.split(':')[1].strip() client = Bittrex(api_key, api_secret, api_version=API_V1_1) try: r = client.list_markets_by_currency(cur) print(r) return r except Exception as e: print(e)
def bittrex_getticker(chat_id, **params): full_api = getbittrexapi(chat_id)['bittrex_api'] api_key = full_api.split(':')[0].strip() api_secret = full_api.split(':')[1].strip() client = Bittrex(api_key, api_secret, api_version=API_V1_1) try: r = client.get_ticker(**params) print(r) return r except Exception as e: print(e)
def enjoycointable(): my_bittrex = Bittrex(None, None, api_version=API_V2_0) data = my_bittrex.get_market_summaries() for x in range(len(data['result'])): market_name = data['result'][x]['Summary']['MarketName'] coin_name = market_name[4:len(market_name)] if market_name[0:3] == 'BTC': coin = Coin.objects.create(koin_name=coin_name) print(str(data))
def test_handles_none_key_or_secret(self): self.bittrex = Bittrex(None, None) # could call any public method here actual = self.bittrex.get_markets() self.assertTrue(actual['success'], "failed with None key and None secret") self.bittrex = Bittrex("123", None) actual = self.bittrex.get_markets() self.assertTrue(actual['success'], "failed with None secret") self.bittrex = Bittrex(None, "123") self.assertTrue(actual['success'], "failed with None key")
class TestBittrexAccountAPI(unittest.TestCase): """ Integration tests for the Bittrex Account API. * These will fail in the absence of an internet connection or if bittrex API goes down. * They require a valid API key and secret issued by Bittrex. * They also require the presence of a JSON file called secrets.json. It is structured as such: { "key": "12341253456345", "secret": "3345745634234534" } """ def setUp(self): with open("secrets.json") as secrets_file: self.secrets = json.load(secrets_file) secrets_file.close() self.bittrex = Bittrex(self.secrets['key'], self.secrets['secret']) def test_handles_invalid_key_or_secret(self): self.bittrex = Bittrex('invalidkey', self.secrets['secret']) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'Invalid key, valid secret') self.bittrex = Bittrex(None, self.secrets['secret']) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'None key, valid secret') self.bittrex = Bittrex(self.secrets['key'], 'invalidsecret') actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'valid key, invalid secret') self.bittrex = Bittrex(self.secrets['key'], None) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'valid key, None secret') self.bittrex = Bittrex('invalidkey', 'invalidsecret') actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'invalid key, invalid secret') pass def test_get_balance(self): actual = self.bittrex.get_balance('BTC') test_basic_response(self, actual, "getbalance") self.assertTrue(isinstance(actual['result'], dict), "result is not a dict") self.assertEqual(actual['result']['Currency'], "BTC", "requested currency {0:s} does not match returned currency {1:s}" .format("BTC", actual['result']['Currency']))
def setUp(self): self.bittrex = Bittrex(None, None, api_version=API_V2_0)
class TestBittrexV20PublicAPI(unittest.TestCase): """ Integration tests for the Bittrex public API. These will fail in the absence of an internet connection or if bittrex API goes down """ def setUp(self): self.bittrex = Bittrex(None, None, api_version=API_V2_0) def test_handles_none_key_or_secret(self): self.bittrex = Bittrex(None, None, api_version=API_V2_0) # could call any public method here actual = self.bittrex.get_market_summaries() self.assertTrue(actual['success'], "failed with None key and None secret") self.bittrex = Bittrex("123", None, api_version=API_V2_0) actual = self.bittrex.get_market_summaries() self.assertTrue(actual['success'], "failed with None secret") self.bittrex = Bittrex(None, "123", api_version=API_V2_0) actual = self.bittrex.get_market_summaries() self.assertTrue(actual['success'], "failed with None key") def test_get_currencies(self): actual = self.bittrex.get_currencies() test_basic_response(self, actual, "get_currencies") def test_get_ticker(self): self.assertRaisesRegexp(Exception, 'method call not available', self.bittrex.get_ticker, market='BTC-LTC') def test_get_market_summaries(self): actual = self.bittrex.get_market_summaries() test_basic_response(self, actual, "get_market_summaries") def test_get_market_summary(self): actual = self.bittrex.get_market_summary(market='BTC-LTC') test_basic_response(self, actual, "get_market_summary") def test_get_orderbook(self): actual = self.bittrex.get_orderbook('BTC-LTC') test_basic_response(self, actual, "get_orderbook") def test_get_wallet_health(self): actual = self.bittrex.get_wallet_health() test_basic_response(self, actual, "get_wallet_health") self.assertIsInstance(actual['result'], list) @unittest.skip("Endpoint 404s. Is this still a valid 2.0 API?") def test_get_balance_distribution(self): actual = self.bittrex.get_balance_distribution() test_basic_response(self, actual, "get_balance_distribution") self.assertIsInstance(actual['result'], list) def test_get_candles(self): actual = self.bittrex.get_candles('BTC-LTC', tick_interval=TICKINTERVAL_ONEMIN) test_basic_response(self, actual, "test_get_candles") self.assertIsInstance(actual['result'], list) def test_get_latest_candle(self): actual = self.bittrex.get_latest_candle('BTC-LTC', tick_interval=TICKINTERVAL_ONEMIN) test_basic_response(self, actual, "test_get_latest_candle") self.assertIsInstance(actual['result'], list)
class TestBittrexV20AccountAPI(unittest.TestCase): """ Integration tests for the Bittrex Account API. * These will fail in the absence of an internet connection or if bittrex API goes down. * They require a valid API key and secret issued by Bittrex. * They also require the presence of a JSON file called secrets.json. It is structured as such: { "key": "12341253456345", "secret": "3345745634234534" } """ def setUp(self): with open("secrets.json") as secrets_file: self.secrets = json.load(secrets_file) secrets_file.close() self.bittrex = Bittrex(self.secrets['key'], self.secrets['secret'], api_version=API_V2_0) def test_handles_invalid_key_or_secret(self): self.bittrex = Bittrex('invalidkey', self.secrets['secret'], api_version=API_V2_0) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'Invalid key, valid secret') self.bittrex = Bittrex(None, self.secrets['secret'], api_version=API_V2_0) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'None key, valid secret') self.bittrex = Bittrex(self.secrets['key'], 'invalidsecret', api_version=API_V2_0) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'valid key, invalid secret') self.bittrex = Bittrex(self.secrets['key'], None, api_version=API_V2_0) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'valid key, None secret') self.bittrex = Bittrex('invalidkey', 'invalidsecret', api_version=API_V2_0) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'invalid key, invalid secret') def test_get_openorders(self): actual = self.bittrex.get_open_orders('BTC-LTC') test_basic_response(self, actual, "get_openorders") self.assertTrue(isinstance(actual['result'], list), "result is not a list") def test_get_balances(self): actual = self.bittrex.get_balances() test_basic_response(self, actual, "get_balances") self.assertTrue(isinstance(actual['result'], list), "result is not a list") @unittest.skip("the return result is an empty dict. API bug? the 2.0 get_balances works as expected") def test_get_balance(self): actual = self.bittrex.get_balance('BTC') test_basic_response(self, actual, "get_balance") self.assertTrue(isinstance(actual['result'], dict), "result is not a dict") self.assertEqual(actual['result']['Currency'], "BTC", "requested currency {0:s} does not match returned currency {1:s}" .format("BTC", actual['result']['Currency'])) @unittest.skip("my testing account is acting funny this should work") def test_get_depositaddress(self): actual = self.bittrex.get_deposit_address('BTC') test_basic_response(self, actual, "get_deposit_address") def test_get_order_history_all_markets(self): actual = self.bittrex.get_order_history() test_basic_response(self, actual, "get_order_history") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_order_history_one_market(self): actual = self.bittrex.get_order_history(market='BTC-LTC') test_basic_response(self, actual, "get_order_history") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_withdrawlhistory_all_currencies(self): actual = self.bittrex.get_withdrawal_history() test_basic_response(self, actual, "get_withdrawal_history") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_withdrawlhistory_one_currency(self): actual = self.bittrex.get_withdrawal_history('BTC') test_basic_response(self, actual, "get_withdrawal_history") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_deposithistory_all_currencies(self): actual = self.bittrex.get_deposit_history() test_basic_response(self, actual, "get_deposit_history") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_deposithistory_one_currency(self): actual = self.bittrex.get_deposit_history('BTC') test_basic_response(self, actual, "get_deposit_history") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_pending_withdrawals_all_currencies(self): actual = self.bittrex.get_pending_withdrawals() test_basic_response(self, actual, "get_pending_withdrawals") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_pending_withdrawals_one_currency(self): actual = self.bittrex.get_pending_withdrawals('BTC') test_basic_response(self, actual, "get_pending_withdrawals") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_pending_deposits_all_currencies(self): actual = self.bittrex.get_pending_deposits() test_basic_response(self, actual, "get_pending_deposits") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_pending_deposits_one_currency(self): actual = self.bittrex.get_pending_deposits('BTC') test_basic_response(self, actual, "get_pending_deposits") self.assertIsInstance(actual['result'], list, "result is not a list") def test_generate_deposit_address(self): actual = self.bittrex.generate_deposit_address(currency='BTC') test_basic_response(self, actual, "generate_deposit_address") self.assertIsInstance(actual['result'], list, "result is not a list")
class TestBittrexV11PublicAPI(unittest.TestCase): """ Integration tests for the Bittrex public API. These will fail in the absence of an internet connection or if bittrex API goes down """ def setUp(self): self.bittrex = Bittrex(None, None, api_version=API_V1_1) def test_handles_none_key_or_secret(self): self.bittrex = Bittrex(None, None) # could call any public method here actual = self.bittrex.get_markets() self.assertTrue(actual['success'], "failed with None key and None secret") self.bittrex = Bittrex("123", None) actual = self.bittrex.get_markets() self.assertTrue(actual['success'], "failed with None secret") self.bittrex = Bittrex(None, "123") actual = self.bittrex.get_markets() self.assertTrue(actual['success'], "failed with None key") def test_get_markets(self): actual = self.bittrex.get_markets() test_basic_response(self, actual, "get_markets") self.assertTrue(isinstance(actual['result'], list), "result is not a list") self.assertTrue(len(actual['result']) > 0, "result list is 0-length") def test_get_currencies(self): actual = self.bittrex.get_currencies() test_basic_response(self, actual, "get_currencies") def test_get_ticker(self): actual = self.bittrex.get_ticker(market='BTC-LTC') test_basic_response(self, actual, "get_ticker") def test_get_market_summaries(self): actual = self.bittrex.get_market_summaries() test_basic_response(self, actual, "get_market_summaries") def test_get_orderbook(self): actual = self.bittrex.get_orderbook('BTC-LTC', depth_type=BUY_ORDERBOOK) test_basic_response(self, actual, "get_orderbook") def test_get_market_history(self): actual = self.bittrex.get_market_history('BTC-LTC') test_basic_response(self, actual, "get_market_history") def test_list_markets_by_currency(self): actual = self.bittrex.list_markets_by_currency('LTC') self.assertListEqual(['BTC-LTC', 'ETH-LTC', 'USDT-LTC'], actual) def test_get_wallet_health(self): self.assertRaisesRegexp(Exception, 'method call not available', self.bittrex.get_wallet_health) def test_get_balance_distribution(self): self.assertRaisesRegexp(Exception, 'method call not available', self.bittrex.get_balance_distribution) def test_get_candles(self): self.assertRaisesRegexp(Exception, 'method call not available', self.bittrex.get_candles, market='BTC-LTC', tick_interval=TICKINTERVAL_ONEMIN) def test_get_latest_candle(self): self.assertRaisesRegexp(Exception, 'method call not available', self.bittrex.get_latest_candle, market='BTC-LTC', tick_interval=TICKINTERVAL_ONEMIN)
class TestBittrexV11AccountAPI(unittest.TestCase): """ Integration tests for the Bittrex Account API. * These will fail in the absence of an internet connection or if bittrex API goes down. * They require a valid API key and secret issued by Bittrex. * They also require the presence of a JSON file called secrets.json. It is structured as such: { "key": "12341253456345", "secret": "3345745634234534" } """ def setUp(self): with open("secrets.json") as secrets_file: self.secrets = json.load(secrets_file) secrets_file.close() self.bittrex = Bittrex(self.secrets['key'], self.secrets['secret']) def test_handles_invalid_key_or_secret(self): self.bittrex = Bittrex('invalidkey', self.secrets['secret']) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'Invalid key, valid secret') self.bittrex = Bittrex(None, self.secrets['secret']) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'None key, valid secret') self.bittrex = Bittrex(self.secrets['key'], 'invalidsecret') actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'valid key, invalid secret') self.bittrex = Bittrex(self.secrets['key'], None) actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'valid key, None secret') self.bittrex = Bittrex('invalidkey', 'invalidsecret') actual = self.bittrex.get_balance('BTC') test_auth_basic_failures(self, actual, 'invalid key, invalid secret') def test_get_openorders(self): actual = self.bittrex.get_open_orders('BTC-LTC') test_basic_response(self, actual, "get_openorders") self.assertTrue(isinstance(actual['result'], list), "result is not a list") def test_get_balances(self): actual = self.bittrex.get_balances() test_basic_response(self, actual, "get_balances") self.assertTrue(isinstance(actual['result'], list), "result is not a list") def test_get_balance(self): actual = self.bittrex.get_balance('BTC') test_basic_response(self, actual, "get_balance") self.assertTrue(isinstance(actual['result'], dict), "result is not a dict") self.assertEqual(actual['result']['Currency'], "BTC", "requested currency {0:s} does not match returned currency {1:s}" .format("BTC", actual['result']['Currency'])) def test_get_depositaddress(self): actual = self.bittrex.get_deposit_address('BTC') if not actual['success']: self.assertTrue(actual['message'], 'ADDRESS_GENERATING') else: test_basic_response(self, actual, "get_deposit_address") def test_get_order_history_all_markets(self): actual = self.bittrex.get_order_history() test_basic_response(self, actual, "get_order_history") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_order_history_one_market(self): actual = self.bittrex.get_order_history(market='BTC-LTC') test_basic_response(self, actual, "get_order_history") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_withdrawlhistory_all_currencies(self): actual = self.bittrex.get_withdrawal_history() test_basic_response(self, actual, "get_withdrawal_history") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_withdrawlhistory_one_currency(self): actual = self.bittrex.get_withdrawal_history('BTC') test_basic_response(self, actual, "get_withdrawal_history") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_deposithistory_all_currencies(self): actual = self.bittrex.get_deposit_history() test_basic_response(self, actual, "get_deposit_history") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_deposithistory_one_currency(self): actual = self.bittrex.get_deposit_history('BTC') test_basic_response(self, actual, "get_deposit_history") self.assertIsInstance(actual['result'], list, "result is not a list") def test_get_pending_withdrawals(self): self.assertRaisesRegexp(Exception, 'method call not available', self.bittrex.get_pending_withdrawals) def test_get_pending_deposits(self): self.assertRaisesRegexp(Exception, 'method call not available', self.bittrex.get_pending_deposits) def test_generate_deposit_address(self): self.assertRaisesRegexp(Exception, 'method call not available', self.bittrex.generate_deposit_address, currency='BTC')
def setUp(self): self.bittrex = Bittrex(None, None)
from bittrex.bittrex import Bittrex bit = Bittrex(api_key='748fdc31633644849231b13a9f2cafdd', api_secret='25e3129bc6ed4cf3b3d7beaebfc4914e') # Only one instance is ok # Function get_markets #market_list = bit.get_markets() # Uncomment next line to print # print(market_list) # Ticker list example #firs_market = market_list['result'][0]['MarketName'] #ticker_for_the_first_market = bit.get_ticker('BTC-CRAVE') #print (ticker_for_the_first_market) # Buy limit example limit = bit.buy_limit('BTC-CRAVE', float(0.1) , float(2.1)) print(limit)