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')
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
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")
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')
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)
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)
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)
