def test_getTime():
filename = 'config.json'
with open(filename) as config_file:
config = json.load(config_file)
api_key = ''
api_secret = ''
api_passphrase = ''
api_url = ''
if 'api_key' in config and 'api_secret' in config and 'api_pass' in config and 'api_url' in config:
api_key = config['api_key']
api_secret = config['api_secret']
api_passphrase = config['api_pass']
api_url = config['api_url']
elif 'api_key' in config['coinbasepro'] and 'api_secret' in config[
'coinbasepro'] and 'api_passphrase' in config[
'coinbasepro'] and 'api_url' in config['coinbasepro']:
api_key = config['coinbasepro']['api_key']
api_secret = config['coinbasepro']['api_secret']
api_passphrase = config['coinbasepro']['api_passphrase']
api_url = config['coinbasepro']['api_url']
exchange = AuthAPI(api_key, api_secret, api_passphrase, api_url)
assert type(exchange) is AuthAPI
resp = exchange.getTime()
assert type(resp) is datetime
def test_marketBuyInvalidMarket():
filename = 'config.json'
with open(filename) as config_file:
config = json.load(config_file)
api_key = ''
api_secret = ''
api_passphrase = ''
api_url = ''
if 'api_key' in config and 'api_secret' in config and 'api_pass' in config and 'api_url' in config:
api_key = config['api_key']
api_secret = config['api_secret']
api_passphrase = config['api_pass']
api_url = config['api_url']
elif 'api_key' in config['coinbasepro'] and 'api_secret' in config[
'coinbasepro'] and 'api_passphrase' in config[
'coinbasepro'] and 'api_url' in config['coinbasepro']:
api_key = config['coinbasepro']['api_key']
api_secret = config['coinbasepro']['api_secret']
api_passphrase = config['coinbasepro']['api_passphrase']
api_url = config['coinbasepro']['api_url']
exchange = AuthAPI(api_key, api_secret, api_passphrase, api_url)
assert type(exchange) is AuthAPI
with pytest.raises(ValueError) as execinfo:
exchange.marketBuy('ERROR', -1)
assert str(execinfo.value) == 'Coinbase Pro market is invalid.'
def test_getOrdersInvalidStatus():
filename = 'config.json'
with open(filename) as config_file:
config = json.load(config_file)
api_key = ''
api_secret = ''
api_passphrase = ''
api_url = ''
if 'api_key' in config and 'api_secret' in config and 'api_pass' in config and 'api_url' in config:
api_key = config['api_key']
api_secret = config['api_secret']
api_passphrase = config['api_pass']
api_url = config['api_url']
elif 'api_key' in config['coinbasepro'] and 'api_secret' in config[
'coinbasepro'] and 'api_passphrase' in config[
'coinbasepro'] and 'api_url' in config['coinbasepro']:
api_key = config['coinbasepro']['api_key']
api_secret = config['coinbasepro']['api_secret']
api_passphrase = config['coinbasepro']['api_passphrase']
api_url = config['coinbasepro']['api_url']
exchange = AuthAPI(api_key, api_secret, api_passphrase, api_url)
assert type(exchange) is AuthAPI
with pytest.raises(ValueError) as execinfo:
exchange.getOrders(status='ERROR')
assert str(execinfo.value) == 'Invalid order status.'
def test_config_json_exists_and_valid():
filename = 'config.json'
assert os.path.exists(filename) == True
with open(filename) as config_file:
config = json.load(config_file)
api_key = ''
api_secret = ''
api_passphrase = ''
api_url = ''
if 'api_key' in config and 'api_secret' in config and 'api_pass' in config and 'api_url' in config:
api_key = config['api_key']
api_secret = config['api_secret']
api_passphrase = config['api_pass']
api_url = config['api_url']
AuthAPI(api_key, api_secret, api_passphrase, api_url)
elif 'api_key' in config['coinbasepro'] and 'api_secret' in config[
'coinbasepro'] and 'api_passphrase' in config[
'coinbasepro'] and 'api_url' in config['coinbasepro']:
api_key = config['coinbasepro']['api_key']
api_secret = config['coinbasepro']['api_secret']
api_passphrase = config['coinbasepro']['api_passphrase']
api_url = config['coinbasepro']['api_url']
AuthAPI(api_key, api_secret, api_passphrase, api_url)
pass
def test_getMakerFeeWithMarket():
filename = 'config.json'
with open(filename) as config_file:
config = json.load(config_file)
api_key = ''
api_secret = ''
api_passphrase = ''
api_url = ''
if 'api_key' in config and 'api_secret' in config and 'api_pass' in config and 'api_url' in config:
api_key = config['api_key']
api_secret = config['api_secret']
api_passphrase = config['api_pass']
api_url = config['api_url']
elif 'api_key' in config['coinbasepro'] and 'api_secret' in config[
'coinbasepro'] and 'api_passphrase' in config[
'coinbasepro'] and 'api_url' in config['coinbasepro']:
api_key = config['coinbasepro']['api_key']
api_secret = config['coinbasepro']['api_secret']
api_passphrase = config['coinbasepro']['api_passphrase']
api_url = config['coinbasepro']['api_url']
exchange = AuthAPI(api_key, api_secret, api_passphrase, api_url)
assert type(exchange) is AuthAPI
fee = exchange.getMakerFee(VALID_ORDER_MARKET)
assert type(fee) is float
assert fee > 0
def test_marketBuyInvalidAmount():
filename = 'config.json'
with open(filename) as config_file:
config = json.load(config_file)
api_key = ''
api_secret = ''
api_passphrase = ''
api_url = ''
if 'api_key' in config and 'api_secret' in config and 'api_pass' in config and 'api_url' in config:
api_key = config['api_key']
api_secret = config['api_secret']
api_passphrase = config['api_pass']
api_url = config['api_url']
elif 'api_key' in config['coinbasepro'] and 'api_secret' in config[
'coinbasepro'] and 'api_passphrase' in config[
'coinbasepro'] and 'api_url' in config['coinbasepro']:
api_key = config['coinbasepro']['api_key']
api_secret = config['coinbasepro']['api_secret']
api_passphrase = config['coinbasepro']['api_passphrase']
api_url = config['coinbasepro']['api_url']
exchange = AuthAPI(api_key, api_secret, api_passphrase, api_url)
assert type(exchange) is AuthAPI
with pytest.raises(ValueError) as execinfo:
exchange.marketBuy('XXX-YYY', 0)
assert str(execinfo.value) == 'Trade amount is too small (>= 10).'
def test_instantiate_authapi_with_api_passphrase_error():
api_key = "00000000000000000000000000000000"
api_secret = "0000/0000000000/0000000000000000000000000000000000000000000000000000000000/00000000000=="
api_passphrase = "ERROR"
with pytest.raises(SystemExit) as execinfo:
AuthAPI(api_key, api_secret, api_passphrase)
assert str(execinfo.value) == 'Coinbase Pro API passphrase is invalid'
def test_getAccount():
filename = 'config.json'
with open(filename) as config_file:
config = json.load(config_file)
api_key = ''
api_secret = ''
api_passphrase = ''
api_url = ''
if 'api_key' in config and 'api_secret' in config and 'api_pass' in config and 'api_url' in config:
api_key = config['api_key']
api_secret = config['api_secret']
api_passphrase = config['api_pass']
api_url = config['api_url']
elif 'api_key' in config['coinbasepro'] and 'api_secret' in config[
'coinbasepro'] and 'api_passphrase' in config[
'coinbasepro'] and 'api_url' in config['coinbasepro']:
api_key = config['coinbasepro']['api_key']
api_secret = config['coinbasepro']['api_secret']
api_passphrase = config['coinbasepro']['api_passphrase']
api_url = config['coinbasepro']['api_url']
exchange = AuthAPI(api_key, api_secret, api_passphrase, api_url)
assert type(exchange) is AuthAPI
df = exchange.getAccounts()
assert len(df) > 0
account = df[['id']].head(1).values[0][0]
assert len(account) > 0
df = exchange.getAccount(account)
assert type(df) is pandas.core.frame.DataFrame
assert len(df) == 1
actual = df.columns.to_list()
expected = [
'id', 'currency', 'balance', 'hold', 'available', 'profile_id',
'trading_enabled'
]
assert len(actual) == len(expected)
assert all([a == b for a, b in zip(actual, expected)])
def test_instantiate_authapi_with_api_url_error():
api_key = "00000000000000000000000000000000"
api_secret = "0000/0000000000/0000000000000000000000000000000000000000000000000000000000/00000000000=="
api_passphrase = "00000000000"
api_url = "ERROR"
with pytest.raises(ValueError) as execinfo:
AuthAPI(api_key, api_secret, api_passphrase, api_url)
assert str(execinfo.value) == 'Coinbase Pro API URL is invalid'
def getOrders(self, market='', action='', status='all'):
"""Retrieves orders either live or simulation
Parameters
----------
market : str, optional
Filters orders by market
action : str, optional
Filters orders by action
status : str
Filters orders by status, defaults to 'all'
"""
if market != '':
# validate market is syntactically correct
p = re.compile(r"^[A-Z]{3,4}\-[A-Z]{3,4}$")
if not p.match(market):
raise TypeError('Coinbase Pro market is invalid.')
if action != '':
# validate action is either a buy or sell
if not action in ['buy', 'sell']:
raise ValueError('Invalid order action.')
# validate status is open, pending, done, active or all
if not status in ['open', 'pending', 'done', 'active', 'all']:
raise ValueError('Invalid order status.')
if self.mode == 'live':
# if config is provided and live connect to Coinbase Pro account portfolio
model = AuthAPI(self.api_key, self.api_secret, self.api_pass,
self.api_url)
# retrieve orders from live Coinbase Pro account portfolio
self.orders = model.getOrders(market, action, status)
return self.orders
else:
# return dummy orders
if market == '':
return self.orders
else:
return self.orders[self.orders['market'] == market]
def test_getOrdersValidStatusActive():
filename = 'config.json'
with open(filename) as config_file:
config = json.load(config_file)
api_key = ''
api_secret = ''
api_passphrase = ''
api_url = ''
if 'api_key' in config and 'api_secret' in config and 'api_pass' in config and 'api_url' in config:
api_key = config['api_key']
api_secret = config['api_secret']
api_passphrase = config['api_pass']
api_url = config['api_url']
elif 'api_key' in config['coinbasepro'] and 'api_secret' in config[
'coinbasepro'] and 'api_passphrase' in config[
'coinbasepro'] and 'api_url' in config['coinbasepro']:
api_key = config['coinbasepro']['api_key']
api_secret = config['coinbasepro']['api_secret']
api_passphrase = config['coinbasepro']['api_passphrase']
api_url = config['coinbasepro']['api_url']
exchange = AuthAPI(api_key, api_secret, api_passphrase, api_url)
assert type(exchange) is AuthAPI
df = exchange.getOrders(status='active')
if len(df) == 0:
pass
else:
actual = df.columns.to_list()
expected = [
'created_at', 'market', 'action', 'type', 'size', 'value',
'status', 'price'
]
assert len(actual) == len(expected)
assert all([a == b for a, b in zip(actual, expected)])
def getValidOrderMarket() -> str:
filename = 'config.json'
assert os.path.exists(filename) == True
with open(filename) as config_file:
config = json.load(config_file)
if 'api_key' in config and 'api_secret' in config and (
'api_pass' in config
or 'api_passphrase' in config) and 'api_url' in config:
api_key = config['api_key']
api_secret = config['api_secret']
if 'api_pass' in config:
api_passphrase = config['api_pass']
else:
api_passphrase = config['api_passphrase']
api_url = config['api_url']
elif 'coinbasepro' in config:
if 'api_key' in config['coinbasepro'] and 'api_secret' in config[
'coinbasepro'] and 'api_passphrase' in config[
'coinbasepro'] and 'api_url' in config['coinbasepro']:
api_key = config['coinbasepro']['api_key']
api_secret = config['coinbasepro']['api_secret']
api_passphrase = config['coinbasepro']['api_passphrase']
api_url = config['coinbasepro']['api_url']
else:
return DEFAULT_ORDER_MARKET
else:
return DEFAULT_ORDER_MARKET
time.sleep(0.5)
exchange = AuthAPI(api_key, api_secret, api_passphrase, api_url)
df = exchange.getOrders()
if len(df) == 0:
return DEFAULT_ORDER_MARKET
return df['market'].tail(1).values[0]
return DEFAULT_ORDER_MARKET
def test_getFeesWithMarket():
filename = 'config.json'
with open(filename) as config_file:
config = json.load(config_file)
api_key = ''
api_secret = ''
api_passphrase = ''
api_url = ''
if 'api_key' in config and 'api_secret' in config and 'api_pass' in config and 'api_url' in config:
api_key = config['api_key']
api_secret = config['api_secret']
api_passphrase = config['api_pass']
api_url = config['api_url']
elif 'api_key' in config['coinbasepro'] and 'api_secret' in config[
'coinbasepro'] and 'api_passphrase' in config[
'coinbasepro'] and 'api_url' in config['coinbasepro']:
api_key = config['coinbasepro']['api_key']
api_secret = config['coinbasepro']['api_secret']
api_passphrase = config['coinbasepro']['api_passphrase']
api_url = config['coinbasepro']['api_url']
exchange = AuthAPI(api_key, api_secret, api_passphrase, api_url)
assert type(exchange) is AuthAPI
df = exchange.getFees(VALID_ORDER_MARKET)
assert type(df) is pandas.core.frame.DataFrame
assert len(df) == 1
actual = df.columns.to_list()
expected = ['maker_fee_rate', 'taker_fee_rate', 'usd_volume', 'market']
assert len(actual) == len(expected)
assert all([a == b for a, b in zip(actual, expected)])
def sell(self,
cryptoMarket,
fiatMarket,
cryptoAmount,
manualPrice=0.00000000):
"""Places a sell order either live or simulation
Parameters
----------
cryptoMarket: str
Crypto market you wish to purchase
fiatMarket, str
QUOTE market funding the purchase
fiatAmount, float
QUOTE amount of crypto currency to purchase
manualPrice, float
Used for simulations specifying the live price to purchase
"""
if self.app.getExchange() == 'binance':
# validate crypto market is syntactically correct
p = re.compile(r"^[A-Z]{3,8}$")
if not p.match(cryptoMarket):
raise TypeError('Binance crypto market is invalid.')
# validate fiat market is syntactically correct
p = re.compile(r"^[A-Z]{3,8}$")
if not p.match(fiatMarket):
raise TypeError('Binance fiat market is invalid.')
else:
# crypto market should be either BCH, BTC, ETH, LTC or XLM
if cryptoMarket not in ['BCH', 'BTC', 'ETH', 'LTC', 'XLM']:
raise Exception(
'Invalid crypto market: BCH, BTC, ETH, LTC, ETH, or XLM')
# fiat market should be either EUR, GBP, or USD
if fiatMarket not in ['EUR', 'GBP', 'USD']:
raise Exception('Invalid QUOTE market: EUR, GBP, USD')
# reconstruct the exchange market using crypto and fiat inputs
if self.app.getExchange() == 'binance':
market = cryptoMarket + fiatMarket
else:
market = cryptoMarket + '-' + fiatMarket
# crypto amount must be an integer or float
if not isinstance(cryptoAmount, float) and not isinstance(
cryptoAmount, int):
raise TypeError('Crypto amount not numeric.')
# crypto amount must be positive
if cryptoAmount <= 0:
raise Exception('Invalid crypto amount.')
if self.app.getExchange() == 'binance':
if self.mode == 'live':
# execute a live market buy
resp = self.client.order_market_sell(symbol=market,
quantity=cryptoAmount)
# TODO: not finished
print(resp)
else:
# crypto amount should exceed balance
if cryptoAmount > self.getBalance(cryptoMarket):
raise Exception('Insufficient funds.')
# manual price must be an integer or float
if not isinstance(manualPrice, float) and not isinstance(
manualPrice, int):
raise TypeError('Optional manual price not numeric.')
# calculate purchase fees
fee = cryptoAmount * 0.005
cryptoAmountMinusFee = cryptoAmount - fee
price = manualPrice
# if manualPrice is non-positive retrieve the current live price
if manualPrice <= 0:
resp = requests.get(
'https://api-public.sandbox.pro.coinbase.com/products/'
+ market + '/ticker')
if resp.status_code != 200:
raise Exception('GET /products/' + market +
'/ticker {}'.format(resp.status_code))
resp.raise_for_status()
json = resp.json()
price = float(json['price'])
total = price * cryptoAmountMinusFee
# append dummy order into orders dataframe
ts = pd.Timestamp.now()
price = ((price * cryptoAmount) * 100) / (cryptoAmount * 100)
order = pd.DataFrame([[
'', market, 'sell', 'market', cryptoAmountMinusFee,
float('{:.8f}'.format(total)), 'done', '{:.8f}'.format(
float(price))
]],
columns=[
'created_at', 'market', 'action',
'type', 'size', 'value', 'status',
'price'
],
index=[ts])
order['created_at'] = order.index
self.orders = pd.concat(
[self.orders, pd.DataFrame(order)], ignore_index=False)
# update the dummy fiat balance
self.balance.loc[
self.balance['currency'] == fiatMarket,
'balance'] = self.getBalance(fiatMarket) + total
self.balance.loc[
self.balance['currency'] == fiatMarket,
'available'] = self.getBalance(fiatMarket) + total
# update the dummy crypto balance
self.balance.loc[
self.balance['currency'] == cryptoMarket,
'balance'] = self.getBalance(cryptoMarket) - cryptoAmount
self.balance.loc[
self.balance['currency'] == cryptoMarket,
'available'] = self.getBalance(cryptoMarket) - cryptoAmount
else:
if self.mode == 'live':
# connect to Coinbase Pro API live
model = CBAuthAPI(self.app.getAPIKey(),
self.app.getAPISecret(),
self.app.getAPIPassphrase(),
self.app.getAPIURL())
# execute a live market sell
resp = model.marketSell(market,
float(self.getBalance(cryptoMarket)))
# TODO: not finished
print(resp)
else:
# crypto amount should exceed balance
if cryptoAmount > self.getBalance(cryptoMarket):
raise Exception('Insufficient funds.')
# manual price must be an integer or float
if not isinstance(manualPrice, float) and not isinstance(
manualPrice, int):
raise TypeError('Optional manual price not numeric.')
# calculate purchase fees
fee = cryptoAmount * 0.005
cryptoAmountMinusFee = cryptoAmount - fee
price = manualPrice
if manualPrice <= 0:
# if manualPrice is non-positive retrieve the current live price
resp = requests.get(
'https://api-public.sandbox.pro.coinbase.com/products/'
+ market + '/ticker')
if resp.status_code != 200:
raise Exception('GET /products/' + market +
'/ticker {}'.format(resp.status_code))
resp.raise_for_status()
json = resp.json()
price = float(json['price'])
total = price * cryptoAmountMinusFee
# append dummy order into orders dataframe
ts = pd.Timestamp.now()
price = ((price * cryptoAmount) * 100) / (cryptoAmount * 100)
order = pd.DataFrame([[
market, 'sell', 'market', cryptoAmountMinusFee,
float('{:.8f}'.format(total)), 'done', price
]],
columns=[
'market', 'action', 'type', 'size',
'value', 'status', 'price'
],
index=[ts])
order['created_at'] = order.index
self.orders = pd.concat(
[self.orders, pd.DataFrame(order)], ignore_index=False)
# update the dummy fiat balance
self.balance.loc[
self.balance['currency'] == fiatMarket,
'balance'] = self.getBalance(fiatMarket) + total
self.balance.loc[
self.balance['currency'] == fiatMarket,
'available'] = self.getBalance(fiatMarket) + total
# update the dummy crypto balance
self.balance.loc[
self.balance['currency'] == cryptoMarket,
'balance'] = self.getBalance(cryptoMarket) - cryptoAmount
self.balance.loc[
self.balance['currency'] == cryptoMarket,
'available'] = self.getBalance(cryptoMarket) - cryptoAmount
def buy(self,
cryptoMarket,
fiatMarket,
fiatAmount,
manualPrice=0.00000000):
"""Places a buy order either live or simulation
Parameters
----------
cryptoMarket: str
Crypto market you wish to purchase
fiatMarket, str
FIAT market funding the purchase
fiatAmount, float
FIAT amount of crypto currency to purchase
manualPrice, float
Used for simulations specifying the live price to purchase
"""
# fiat funding amount must be an integer or float
if not isinstance(fiatAmount, float) and not isinstance(
fiatAmount, int):
raise TypeError('FIAT amount not numeric.')
# fiat funding amount must be positive
if fiatAmount <= 0:
raise Exception('Invalid FIAT amount.')
# crypto market should be either BCH, BTC, ETH, LTC or XLM
if cryptoMarket not in ['BCH', 'BTC', 'ETH', 'LTC', 'XLM']:
raise Exception(
'Invalid crypto market: BCH, BTC, ETH, LTC, ETH, or XLM')
# fiat market should be either EUR, GBP, or USD
if fiatMarket not in ['EUR', 'GBP', 'USD']:
raise Exception('Invalid FIAT market: EUR, GBP, USD')
# reconstruct the exchange market using crypto and fiat inputs
market = cryptoMarket + '-' + fiatMarket
if self.mode == 'live':
# connect to coinbase pro api (authenticated)
model = AuthAPI(self.api_key, self.api_secret, self.api_pass,
self.api_url)
# execute a live market buy
resp = model.marketBuy(market, float(self.getBalance(fiatMarket)))
# TODO: not finished
print(resp)
else:
# fiat amount should exceed balance
if fiatAmount > self.getBalance(fiatMarket):
raise Exception('Insufficient funds.')
# manual price must be an integer or float
if not isinstance(manualPrice, float) and not isinstance(
manualPrice, int):
raise TypeError('Optional manual price not numeric.')
price = manualPrice
# if manualPrice is non-positive retrieve the current live price
if manualPrice <= 0:
resp = requests.get(
'https://api-public.sandbox.pro.coinbase.com/products/BTC-GBP/ticker'
)
if resp.status_code != 200:
raise Exception('GET /products/' + market +
'/ticker {}'.format(resp.status_code))
resp.raise_for_status()
json = resp.json()
price = float(json['price'])
# calculate purchase fees
fee = fiatAmount * 0.005
fiatAmountMinusFee = fiatAmount - fee
total = float(fiatAmountMinusFee / price)
# append dummy order into orders dataframe
ts = pd.Timestamp.now()
price = (fiatAmountMinusFee * 100) / (total * 100)
order = pd.DataFrame([[
market, 'buy', 'market',
float('{:.8f}'.format(total)), fiatAmountMinusFee, 'done',
price
]],
columns=[
'market', 'action', 'type', 'size',
'value', 'status', 'price'
],
index=[ts])
self.orders = pd.concat(
[self.orders, pd.DataFrame(order)], ignore_index=False)
# update the dummy fiat balance
self.balance.loc[
self.balance['currency'] == fiatMarket,
'balance'] = self.getBalance(fiatMarket) - fiatAmount
self.balance.loc[
self.balance['currency'] == fiatMarket,
'available'] = self.getBalance(fiatMarket) - fiatAmount
# update the dummy crypto balance
self.balance.loc[self.balance['currency'] == cryptoMarket,
'balance'] = self.getBalance(cryptoMarket) + (
fiatAmountMinusFee / price)
self.balance.loc[self.balance['currency'] == cryptoMarket,
'available'] = self.getBalance(cryptoMarket) + (
fiatAmountMinusFee / price)
def saveTrackerCSV(self, market='', save_file='tracker.csv'):
"""Saves order tracker to CSV
Parameters
----------
market : str, optional
Filters orders by market
save_file : str
Output CSV file
"""
if market != '':
# validate market is syntactically correct
p = re.compile(r"^[A-Z]{3,4}\-[A-Z]{3,4}$")
if not p.match(market):
raise TypeError('Coinbase Pro market is invalid.')
if self.mode == 'live':
# if config is provided and live connect to Coinbase Pro account portfolio
model = AuthAPI(self.api_key, self.api_secret, self.api_pass,
self.api_url)
# retrieve orders from live Coinbase Pro account portfolio
df = model.getOrders(market, '', 'done')
else:
# return dummy orders
if market == '':
df = self.orders
else:
df = self.orders[self.orders['market'] == market]
if list(df.keys()) != [
'created_at', 'market', 'action', 'type', 'size', 'value',
'status', 'price'
]:
# no data, return early
return False
df_tracker = pd.DataFrame()
last_action = ''
for market in df['market'].sort_values().unique():
df_market = df[df['market'] == market]
df_buy = pd.DataFrame()
df_sell = pd.DataFrame()
pair = 0
# pylint: disable=unused-variable
for index, row in df_market.iterrows():
if row['action'] == 'buy':
pair = 1
if pair == 1 and (row['action'] != last_action):
if row['action'] == 'buy':
df_buy = row
elif row['action'] == 'sell':
df_sell = row
if row['action'] == 'sell' and len(df_buy) != 0:
df_pair = pd.DataFrame([[
df_sell['status'], df_buy['market'],
df_buy['created_at'], df_buy['type'], df_buy['size'],
df_buy['value'], df_buy['price'],
df_sell['created_at'], df_sell['type'],
df_sell['size'], df_sell['value'], df_sell['price']
]],
columns=[
'status', 'market', 'buy_at',
'buy_type', 'buy_size',
'buy_value', 'buy_price',
'sell_at', 'sell_type',
'sell_size', 'sell_value',
'sell_price'
])
df_tracker = df_tracker.append(df_pair, ignore_index=True)
pair = 0
last_action = row['action']
if list(df_tracker.keys()) != [
'status', 'market', 'buy_at', 'buy_type', 'buy_size',
'buy_value', 'buy_price', 'sell_at', 'sell_type', 'sell_size',
'sell_value', 'sell_price'
]:
# no data, return early
return False
df_tracker['profit'] = np.subtract(df_tracker['sell_value'],
df_tracker['buy_value'])
df_tracker['margin'] = np.multiply(
np.true_divide(df_tracker['profit'], df_tracker['sell_value']),
100)
df_sincebot = df_tracker[df_tracker['buy_at'] > '2021-02-1']
try:
df_sincebot.to_csv(save_file, index=False)
except OSError:
raise SystemExit('Unable to save: ', save_file)
def getBalance(self, currency=''):
"""Retrieves balance either live or simulation
Parameters
----------
currency: str, optional
Filters orders by currency
"""
if self.mode == 'live':
# if config is provided and live connect to Coinbase Pro account portfolio
model = AuthAPI(self.api_key, self.api_secret, self.api_pass,
self.api_url)
if currency == '':
# retrieve all balances
return model.getAccounts()[[
'currency', 'balance', 'hold', 'available'
]]
else:
df = model.getAccounts()
# retrieve balance of specified currency
df_filtered = df[df['currency'] == currency]['available']
if len(df_filtered) == 0:
# return nil balance if no positive balance was found
return 0.0
else:
# return balance of specified currency (if positive)
if currency in ['EUR', 'GBP', 'USD']:
return self.truncate(
float(df[df['currency'] == currency]
['available'].values[0]), 2)
else:
return self.truncate(
float(df[df['currency'] == currency]
['available'].values[0]), 4)
else:
# return dummy balances
if currency == '':
# retrieve all balances
return self.balance
else:
# replace FIAT and CRYPTO placeholders
if currency in ['EUR', 'GBP', 'USD']:
self.balance = self.balance.replace('FIAT', currency)
elif currency in ['BCH', 'BTC', 'ETH', 'LTC', 'XLM']:
self.balance = self.balance.replace('CRYPTO', currency)
if self.balance.currency[self.balance.currency.isin(
[currency])].empty == True:
self.balance.loc[len(self.balance)] = [currency, 0, 0, 0]
# retrieve balance of specified currency
df = self.balance
df_filtered = df[df['currency'] == currency]['available']
if len(df_filtered) == 0:
# return nil balance if no positive balance was found
return 0.0
else:
# return balance of specified currency (if positive)
if currency in ['EUR', 'GBP', 'USD']:
return self.truncate(
float(df[df['currency'] == currency]
['available'].values[0]), 2)
else:
return self.truncate(
float(df[df['currency'] == currency]
['available'].values[0]), 4)
def executeJob(sc, market, granularity, tradingData=pd.DataFrame()):
"""Trading bot job which runs at a scheduled interval"""
global action, buy_count, buy_sum, failsafe, iterations, last_action, last_buy, last_df_index, sell_count, sell_sum, x_since_buy, x_since_sell
# increment iterations
iterations = iterations + 1
if is_sim == 0:
# retrieve the market data
api = PublicAPI()
tradingData = api.getHistoricalData(market, granularity)
# analyse the market data
tradingDataCopy = tradingData.copy()
technicalAnalysis = TechnicalAnalysis(tradingDataCopy)
technicalAnalysis.addAll()
df = technicalAnalysis.getDataFrame()
if len(df) != 300:
# data frame should have 300 rows, if not retry
print('error: data frame length is < 300 (' + str(len(df)) + ')')
logging.error('error: data frame length is < 300 (' + str(len(df)) +
')')
s.enter(300, 1, executeJob, (sc, market, granularity))
if is_sim == 1:
# with a simulation df_last will iterate through data
df_last = df.iloc[iterations - 1:iterations]
else:
# df_last contains the most recent entry
df_last = df.tail(1)
price = float(df_last['close'].values[0])
ema12gtema26 = bool(df_last['ema12gtema26'].values[0])
ema12gtema26co = bool(df_last['ema12gtema26co'].values[0])
macdgtsignal = bool(df_last['macdgtsignal'].values[0])
macdgtsignalco = bool(df_last['macdgtsignalco'].values[0])
ema12ltema26 = bool(df_last['ema12ltema26'].values[0])
ema12ltema26co = bool(df_last['ema12ltema26co'].values[0])
macdltsignal = bool(df_last['macdltsignal'].values[0])
macdltsignalco = bool(df_last['macdltsignalco'].values[0])
obv = float(df_last['obv'].values[0])
obv_pc = float(df_last['obv_pc'].values[0])
# candlestick detection
hammer = bool(df_last['hammer'].values[0])
inverted_hammer = bool(df_last['inverted_hammer'].values[0])
hanging_man = bool(df_last['hanging_man'].values[0])
shooting_star = bool(df_last['shooting_star'].values[0])
three_white_soldiers = bool(df_last['three_white_soldiers'].values[0])
three_black_crows = bool(df_last['three_black_crows'].values[0])
morning_star = bool(df_last['morning_star'].values[0])
evening_star = bool(df_last['evening_star'].values[0])
three_line_strike = bool(df_last['three_line_strike'].values[0])
abandoned_baby = bool(df_last['abandoned_baby'].values[0])
morning_doji_star = bool(df_last['morning_doji_star'].values[0])
evening_doji_star = bool(df_last['evening_doji_star'].values[0])
two_black_gapping = bool(df_last['two_black_gapping'].values[0])
# criteria for a buy signal
if ((ema12gtema26co == True and macdgtsignal == True
and macdgtsignal > 0.1) or
(ema12gtema26 == True and macdgtsignal == True and x_since_buy > 0
and x_since_buy <= 2)) and last_action != 'BUY':
action = 'BUY'
# criteria for a sell signal
elif ((ema12ltema26co == True and macdltsignal == True) or
(ema12ltema26 == True and macdltsignal == True and x_since_sell > 0
and x_since_sell <= 2)) and last_action not in ['', 'SELL']:
action = 'SELL'
failsafe = False
# anything other than a buy or sell, just wait
else:
action = 'WAIT'
# loss failsafe sell < -5%
if last_buy > 0 and last_action == 'BUY':
change_pcnt = ((price / last_buy) - 1) * 100
if (change_pcnt < -5):
action = 'SELL'
x_since_buy = 0
failsafe = True
log_text = '! Loss Failsafe Triggered (< -5%)'
print(log_text, "\n")
logging.warning(log_text)
# polling is every 5 minutes (even for hourly intervals), but only process once per interval
if (last_df_index != df_last.index.format()):
ts_text = str(df_last.index.format()[0])
precision = 2
if cryptoMarket == 'XLM':
precision = 4
price_text = 'Price: ' + str(
truncate(float(df_last['close'].values[0]), precision))
ema_text = compare(df_last['ema12'].values[0],
df_last['ema26'].values[0], 'EMA12/26', precision)
macd_text = compare(df_last['macd'].values[0],
df_last['signal'].values[0], 'MACD', precision)
obv_text = compare(df_last['obv_pc'].values[0], 0.1, 'OBV %',
precision)
counter_text = '[I:' + str(iterations) + ',B:' + str(
x_since_buy) + ',S:' + str(x_since_sell) + ']'
if hammer == True:
log_text = '* Candlestick Detected: Hammer ("Weak - Reversal - Bullish Signal - Up")'
print(log_text, "\n")
logging.debug(log_text)
if shooting_star == True:
log_text = '* Candlestick Detected: Shooting Star ("Weak - Reversal - Bearish Pattern - Down")'
print(log_text, "\n")
logging.debug(log_text)
if hanging_man == True:
log_text = '* Candlestick Detected: Hanging Man ("Weak - Continuation - Bearish Pattern - Down")'
print(log_text, "\n")
logging.debug(log_text)
if inverted_hammer == True:
log_text = '* Candlestick Detected: Inverted Hammer ("Weak - Continuation - Bullish Pattern - Up")'
print(log_text, "\n")
logging.debug(log_text)
if three_white_soldiers == True:
log_text = '*** Candlestick Detected: Three White Soldiers ("Strong - Reversal - Bullish Pattern - Up")'
print(log_text, "\n")
logging.debug(log_text)
if three_black_crows == True:
log_text = '* Candlestick Detected: Three Black Crows ("Strong - Reversal - Bearish Pattern - Down")'
print(log_text, "\n")
logging.debug(log_text)
if morning_star == True:
log_text = '*** Candlestick Detected: Morning Star ("Strong - Reversal - Bullish Pattern - Up")'
print(log_text, "\n")
logging.debug(log_text)
if evening_star == True:
log_text = '*** Candlestick Detected: Evening Star ("Strong - Reversal - Bearish Pattern - Down")'
print(log_text, "\n")
logging.debug(log_text)
if three_line_strike == True:
log_text = '** Candlestick Detected: Three Line Strike ("Reliable - Reversal - Bullish Pattern - Up")'
print(log_text, "\n")
logging.debug(log_text)
if abandoned_baby == True:
log_text = '** Candlestick Detected: Abandoned Baby ("Reliable - Reversal - Bullish Pattern - Up")'
print(log_text, "\n")
logging.debug(log_text)
if morning_doji_star == True:
log_text = '** Candlestick Detected: Morning Doji Star ("Reliable - Reversal - Bullish Pattern - Up")'
print(log_text, "\n")
logging.debug(log_text)
if evening_doji_star == True:
log_text = '** Candlestick Detected: Evening Doji Star ("Reliable - Reversal - Bearish Pattern - Down")'
print(log_text, "\n")
logging.debug(log_text)
if two_black_gapping == True:
log_text = '*** Candlestick Detected: Two Black Gapping ("Reliable - Reversal - Bearish Pattern - Down")'
print(log_text, "\n")
logging.debug(log_text)
ema_co_prefix = ''
ema_co_suffix = ''
if ema12gtema26co == True:
ema_co_prefix = '*^ '
ema_co_suffix = ' ^*'
elif ema12ltema26co == True:
ema_co_prefix = '*v '
ema_co_suffix = ' v*'
elif ema12gtema26 == True:
ema_co_prefix = '^ '
ema_co_suffix = ' ^'
elif ema12ltema26 == True:
ema_co_prefix = 'v '
ema_co_suffix = ' v'
macd_co_prefix = ''
macd_co_suffix = ''
if macdgtsignalco == True:
macd_co_prefix = '*^ '
macd_co_suffix = ' ^*'
elif macdltsignalco == True:
macd_co_prefix = '*v '
macd_co_suffix = ' v*'
elif macdgtsignal == True:
macd_co_prefix = '^ '
macd_co_suffix = ' ^'
elif macdltsignal == True:
macd_co_prefix = 'v '
macd_co_suffix = ' v'
obv_prefix = ''
obv_suffix = ''
if (obv_pc > 0.1):
obv_prefix = '^ '
obv_suffix = ' ^'
else:
obv_prefix = 'v '
obv_suffix = ' v'
if is_verbose == 0:
if last_action != '':
output_text = ts_text + ' | ' + price_text + ' | ' + ema_co_prefix + ema_text + ema_co_suffix + ' | ' + macd_co_prefix + macd_text + macd_co_suffix + ' | ' + obv_prefix + obv_text + obv_suffix + ' | ' + action + ' ' + counter_text + ' | Last Action: ' + last_action
else:
output_text = ts_text + ' | ' + price_text + ' | ' + ema_co_prefix + ema_text + ema_co_suffix + ' | ' + macd_co_prefix + macd_text + macd_co_suffix + ' | ' + obv_prefix + obv_text + obv_suffix + ' | ' + action + ' ' + counter_text
if last_action == 'BUY':
# calculate last buy minus fees
fee = last_buy * 0.005
last_buy_minus_fees = last_buy + fee
margin = str(
truncate((((price - last_buy_minus_fees) / price) * 100),
2)) + '%'
output_text += ' | ' + margin
logging.debug(output_text)
print(output_text)
else:
logging.debug('-- Iteration: ' + str(iterations) + ' --')
logging.debug('-- Since Last Buy: ' + str(x_since_buy) + ' --')
logging.debug('-- Since Last Sell: ' + str(x_since_sell) + ' --')
if last_action == 'BUY':
margin = str(truncate(
(((price - last_buy) / price) * 100), 2)) + '%'
logging.debug('-- Margin: ' + margin + '% --')
logging.debug('price: ' +
str(truncate(float(df_last['close'].values[0]), 2)))
logging.debug('ema12: ' +
str(truncate(float(df_last['ema12'].values[0]), 2)))
logging.debug('ema26: ' +
str(truncate(float(df_last['ema26'].values[0]), 2)))
logging.debug('ema12gtema26co: ' + str(ema12gtema26co))
logging.debug('ema12gtema26: ' + str(ema12gtema26))
logging.debug('ema12ltema26co: ' + str(ema12ltema26co))
logging.debug('ema12ltema26: ' + str(ema12ltema26))
logging.debug('macd: ' +
str(truncate(float(df_last['macd'].values[0]), 2)))
logging.debug('signal: ' +
str(truncate(float(df_last['signal'].values[0]), 2)))
logging.debug('macdgtsignal: ' + str(macdgtsignal))
logging.debug('macdltsignal: ' + str(macdltsignal))
logging.debug('obv: ' + str(obv))
logging.debug('obv_pc: ' + str(obv_pc) + '%')
logging.debug('action: ' + action)
# informational output on the most recent entry
print('')
print(
'================================================================================'
)
txt = ' Iteration : ' + str(iterations)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Since Last Buy : ' + str(x_since_buy)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Since Last Sell : ' + str(x_since_sell)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Timestamp : ' + str(df_last.index.format()[0])
print('|', txt, (' ' * (75 - len(txt))), '|')
print(
'--------------------------------------------------------------------------------'
)
txt = ' EMA12 : ' + str(
truncate(float(df_last['ema12'].values[0]), 2))
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' EMA26 : ' + str(
truncate(float(df_last['ema26'].values[0]), 2))
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Crossing Above : ' + str(ema12gtema26co)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Currently Above : ' + str(ema12gtema26)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Crossing Below : ' + str(ema12ltema26co)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Currently Below : ' + str(ema12ltema26)
print('|', txt, (' ' * (75 - len(txt))), '|')
if (ema12gtema26 == True and ema12gtema26co == True):
txt = ' Condition : EMA12 is currently crossing above EMA26'
elif (ema12gtema26 == True and ema12gtema26co == False):
txt = ' Condition : EMA12 is currently above EMA26 and has crossed over'
elif (ema12ltema26 == True and ema12ltema26co == True):
txt = ' Condition : EMA12 is currently crossing below EMA26'
elif (ema12ltema26 == True and ema12ltema26co == False):
txt = ' Condition : EMA12 is currently below EMA26 and has crossed over'
else:
txt = ' Condition : -'
print('|', txt, (' ' * (75 - len(txt))), '|')
print(
'--------------------------------------------------------------------------------'
)
txt = ' MACD : ' + str(
truncate(float(df_last['macd'].values[0]), 2))
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Signal : ' + str(
truncate(float(df_last['signal'].values[0]), 2))
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Currently Above : ' + str(macdgtsignal)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Currently Below : ' + str(macdltsignal)
print('|', txt, (' ' * (75 - len(txt))), '|')
if (macdgtsignal == True and macdgtsignalco == True):
txt = ' Condition : MACD is currently crossing above Signal'
elif (macdgtsignal == True and macdgtsignalco == False):
txt = ' Condition : MACD is currently above Signal and has crossed over'
elif (macdltsignal == True and macdltsignalco == True):
txt = ' Condition : MACD is currently crossing below Signal'
elif (macdltsignal == True and macdltsignalco == False):
txt = ' Condition : MACD is currently below Signal and has crossed over'
else:
txt = ' Condition : -'
print('|', txt, (' ' * (75 - len(txt))), '|')
print(
'--------------------------------------------------------------------------------'
)
txt = ' OBV : ' + str(truncate(obv, 4))
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' OBV Change : ' + str(obv_pc) + '%'
print('|', txt, (' ' * (75 - len(txt))), '|')
if (obv_pc >= 2):
txt = ' Condition : Large positive volume changes'
elif (obv_pc < 2 and obv_pc >= 0):
txt = ' Condition : Positive volume changes'
else:
txt = ' Condition : Negative volume changes'
print('|', txt, (' ' * (75 - len(txt))), '|')
print(
'--------------------------------------------------------------------------------'
)
txt = ' Action : ' + action
print('|', txt, (' ' * (75 - len(txt))), '|')
print(
'================================================================================'
)
if last_action == 'BUY':
txt = ' Margin : ' + margin + '%'
print('|', txt, (' ' * (75 - len(txt))), '|')
print(
'================================================================================'
)
# increment x since buy
if (ema12gtema26 == True and failsafe == False):
x_since_buy = x_since_buy + 1
# increment x since sell
elif (ema12ltema26 == True):
x_since_sell = x_since_sell + 1
# if a buy signal
if action == 'BUY':
buy_count = buy_count + 1
# reset x since sell
x_since_sell = 0
last_buy = price
# if live
if is_live == 1:
if is_verbose == 0:
logging.info(ts_text + ' | ' + market + ' ' +
str(granularity) + ' | ' + price_text +
' | BUY')
print("\n", ts_text, '|', market, granularity, '|',
price_text, '| BUY', "\n")
else:
print(
'--------------------------------------------------------------------------------'
)
print(
'| *** Executing LIVE Buy Order *** |'
)
print(
'--------------------------------------------------------------------------------'
)
# connect to coinbase pro api (authenticated)
model = AuthAPI(config['api_key'], config['api_secret'],
config['api_pass'], config['api_url'])
# execute a live market buy
resp = model.marketBuy(market,
float(account.getBalance(fiatMarket)))
logging.info(resp)
#logging.info('attempt to buy ' + resp['specified_funds'] + ' (' + resp['funds'] + ' after fees) of ' + resp['product_id'])
# if not live
else:
if is_verbose == 0:
logging.info(ts_text + ' | ' + market + ' ' +
str(granularity) + ' | ' + price_text +
' | BUY')
print("\n", ts_text, '|', market, granularity, '|',
price_text, '| BUY', "\n")
else:
print(
'--------------------------------------------------------------------------------'
)
print(
'| *** Executing TEST Buy Order *** |'
)
print(
'--------------------------------------------------------------------------------'
)
#print(df_last[['close','ema12','ema26','ema12gtema26','ema12gtema26co','macd','signal','macdgtsignal','obv','obv_pc']])
if save_graphs == 1:
tradinggraphs = TradingGraphs(technicalAnalysis)
ts = datetime.now().timestamp()
filename = 'BTC-GBP_3600_buy_' + str(ts) + '.png'
tradinggraphs.renderEMAandMACD(24, 'graphs/' + filename, True)
# if a sell signal
elif action == 'SELL':
sell_count = sell_count + 1
# reset x since buy
x_since_buy = 0
# if live
if is_live == 1:
if is_verbose == 0:
logging.info(ts_text + ' | ' + market + ' ' +
str(granularity) + ' | ' + price_text +
' | SELL')
print("\n", ts_text, '|', market, granularity, '|',
price_text, '| SELL', "\n")
else:
print(
'--------------------------------------------------------------------------------'
)
print(
'| *** Executing LIVE Sell Order *** |'
)
print(
'--------------------------------------------------------------------------------'
)
# connect to Coinbase Pro API live
model = AuthAPI(config['api_key'], config['api_secret'],
config['api_pass'], config['api_url'])
# execute a live market sell
resp = model.marketSell(
market, float(account.getBalance(cryptoMarket)))
logging.info(resp)
#logging.info('attempt to sell ' + resp['size'] + ' of ' + resp['product_id'])
# if not live
else:
if is_verbose == 0:
sell_price = float(
str(
truncate(float(df_last['close'].values[0]),
precision)))
last_buy_price = float(
str(truncate(float(last_buy), precision)))
buy_sell_diff = round(
np.subtract(sell_price, last_buy_price), precision)
buy_sell_margin_no_fees = str(
truncate(
(((sell_price - last_buy_price) / sell_price) *
100), 2)) + '%'
# calculate last buy minus fees
buy_fee = last_buy_price * 0.005
last_buy_price_minus_fees = last_buy_price + buy_fee
buy_sell_margin_fees = str(
truncate((((sell_price - last_buy_price_minus_fees) /
sell_price) * 100), 2)) + '%'
logging.info(ts_text + ' | ' + market + ' ' +
str(granularity) + ' | SELL | ' +
str(sell_price) + ' | BUY | ' +
str(last_buy_price) + ' | DIFF | ' +
str(buy_sell_diff) + ' | MARGIN NO FEES | ' +
str(buy_sell_margin_no_fees) +
' | MARGIN FEES | ' +
str(buy_sell_margin_fees))
print("\n", ts_text, '|', market, granularity, '| SELL |',
str(sell_price), '| BUY |', str(last_buy_price),
'| DIFF |', str(buy_sell_diff), '| MARGIN NO FEES |',
str(buy_sell_margin_no_fees), '| MARGIN FEES |',
str(buy_sell_margin_fees), "\n")
buy_sum = buy_sum + last_buy_price_minus_fees
sell_sum = sell_sum + sell_price
else:
print(
'--------------------------------------------------------------------------------'
)
print(
'| *** Executing TEST Sell Order *** |'
)
print(
'--------------------------------------------------------------------------------'
)
#print(df_last[['close','ema12','ema26','ema12ltema26','ema12ltema26co','macd','signal','macdltsignal','obv','obv_pc']])
if save_graphs == 1:
tradinggraphs = TradingGraphs(technicalAnalysis)
ts = datetime.now().timestamp()
filename = 'BTC-GBP_3600_buy_' + str(ts) + '.png'
tradinggraphs.renderEMAandMACD(24, 'graphs/' + filename, True)
# last significant action
if action in ['BUY', 'SELL']:
last_action = action
last_df_index = df_last.index.format()
if iterations == 300:
print("\nSimulation Summary\n")
if buy_count > sell_count:
# calculate last buy minus fees
fee = last_buy * 0.005
last_buy_minus_fees = last_buy + fee
buy_sum = buy_sum + (float(
truncate(float(df_last['close'].values[0]), precision)) -
last_buy_minus_fees)
print(' Buy Count :', buy_count)
print(' Sell Count :', sell_count, "\n")
print(' Buy Total :', buy_sum)
print(' Sell Total :', sell_sum)
print(
' Margin :',
str(truncate(
(((sell_sum - buy_sum) / sell_sum) * 100), 2)) + '%', "\n")
else:
# decrement ignored iteration
iterations = iterations - 1
# if live
if is_live == 1:
# save csv with orders for market that are 'done'
orders = account.getOrders(market, '', 'done')
orders.to_csv('orders.csv', index=False)
if is_sim == 1:
if iterations < 300:
if sim_speed == 'fast':
# fast processing
executeJob(sc, market, granularity, tradingData)
else:
# slow processing
s.enter(1, 1, executeJob,
(sc, market, granularity, tradingData))
else:
# poll every 5 minutes
s.enter(300, 1, executeJob, (sc, market, granularity))
last_action = 'BUY'
elif (market.startswith('BCH-')
and account.getBalance(cryptoMarket) > 0.01):
last_action = 'BUY'
elif (market.startswith('ETH-')
and account.getBalance(cryptoMarket) > 0.01):
last_action = 'BUY'
elif (market.startswith('LTC-')
and account.getBalance(cryptoMarket) > 0.1):
last_action = 'BUY'
elif (market.startswith('XLM-') and account.getBalance(cryptoMarket) > 35):
last_action = 'BUY'
elif (account.getBalance(fiatMarket) > 30):
last_action = 'SELL'
authAPI = AuthAPI(config['api_key'], config['api_secret'],
config['api_pass'], config['api_url'])
orders = authAPI.getOrders(market)
if len(orders) > 0:
df = orders[-1:]
price = df[df.action == 'buy']['price']
if len(price) > 0:
last_buy = float(truncate(price, 2))
def executeJob(sc, market, granularity, tradingData=pd.DataFrame()):
"""Trading bot job which runs at a scheduled interval"""
global action, buy_count, buy_sum, failsafe, iterations, last_action, last_buy, last_df_index, sell_count, sell_sum, x_since_buy, x_since_sell
# increment iterations
iterations = iterations + 1
printHelp()
sys.exit()
if 'cryptoMarket' in config:
base_currency = config['cryptoMarket']
elif 'base_currency' in config:
base_currency = config['base_currency']
if 'fiatMarket' in config:
quote_currency = config['fiatMarket']
elif 'base_currency' in config:
quote_currency = config['quote_currency']
market = base_currency + '-' + quote_currency
api = CBAuthAPI(api_key, api_secret, api_pass)
orders = api.getOrders()
df = pd.concat([df, orders])
transfers = api.getTransfers()
df = pd.concat([df, transfers])
df['created_at'] = df['created_at'].map(
lambda x: re.sub(r"\.\d{1,6}\+00$", "", str(x)))
df['created_at'] = df['created_at'].map(
lambda x: re.sub(r"\+00:00$", "", str(x)))
save_file = 'profitandloss.csv'
try:
printHelp()
sys.exit()
if 'cryptoMarket' in config:
base_currency = config['cryptoMarket']
elif 'base_currency' in config:
base_currency = config['base_currency']
if 'fiatMarket' in config:
quote_currency = config['fiatMarket']
elif 'base_currency' in config:
quote_currency = config['quote_currency']
market = base_currency + '-' + quote_currency
api = CBAuthAPI(api_key, api_secret, api_pass)
orders = api.getOrders(market)
last_action = ''
if len(orders) > 0:
for market in orders['market'].sort_values().unique():
df_market = orders[orders['market'] == market]
else:
df_market = pd.DataFrame()
df_buy = pd.DataFrame()
df_sell = pd.DataFrame()
pair = 0
# pylint: disable=unused-variable
for index, row in df_market.iterrows():
def test_instantiate_authapi_without_error():
api_key = "00000000000000000000000000000000"
api_secret = "0000/0000000000/0000000000000000000000000000000000000000000000000000000000/00000000000=="
api_passphrase = "00000000000"
exchange = AuthAPI(api_key, api_secret, api_passphrase)
assert type(exchange) is AuthAPI
import json
from models.CoinbasePro import AuthAPI
with open('config.json') as config_file:
config = json.load(config_file)
model = AuthAPI(config['api_key'], config['api_secret'], config['api_pass'], config['api_url'])
resp = model.authAPI('GET','orders?status=all')
print (resp)
accounts = model.getAccounts()
print (accounts)
#account = model.getAccount('00000000-0000-0000-0000-000000000000')
#print (account)
orders1 = model.getOrders()
print (orders1)
orders2 = model.getOrders('BTC-GBP')
print (orders2)
orders3 = model.getOrders('BTC-GBP', 'buy')
print (orders3)
orders4 = model.getOrders('BTC-GBP', 'buy', 'done')
print (orders4)
#order = model.marketBuy('BTC-GBP', 100)
#print (order)
def getBalance(self, currency=''):
"""Retrieves balance either live or simulation
Parameters
----------
currency: str, optional
Filters orders by currency
"""
if self.app.getExchange() == 'binance':
if self.mode == 'live':
resp = self.client.get_account()
if 'balances' in resp:
df = pd.DataFrame(resp['balances'])
df = df[(df['free'] != '0.00000000')
& (df['free'] != '0.00')]
df['free'] = df['free'].astype(float)
df['locked'] = df['locked'].astype(float)
df['balance'] = df['free'] - df['locked']
df.columns = ['currency', 'available', 'hold', 'balance']
df = df[['currency', 'balance', 'hold', 'available']]
df = df.reset_index(drop=True)
if currency == '':
# retrieve all balances
return df
else:
# retrieve balance of specified currency
df_filtered = df[df['currency'] ==
currency]['available']
if len(df_filtered) == 0:
# return nil balance if no positive balance was found
return 0.0
else:
# return balance of specified currency (if positive)
if currency in ['EUR', 'GBP', 'USD']:
return float(
self.app.truncate(
float(df[df['currency'] == currency]
['available'].values[0]), 2))
else:
return float(
self.app.truncate(
float(df[df['currency'] == currency]
['available'].values[0]), 4))
else:
return 0.0
else:
# return dummy balances
if currency == '':
# retrieve all balances
return self.balance
else:
if self.app.getExchange() == 'binance':
self.balance = self.balance.replace('QUOTE', currency)
else:
# replace QUOTE and BASE placeholders
if currency in ['EUR', 'GBP', 'USD']:
self.balance = self.balance.replace(
'QUOTE', currency)
else:
self.balance = self.balance.replace(
'BASE', currency)
if self.balance.currency[self.balance.currency.isin(
[currency])].empty == True:
self.balance.loc[len(
self.balance)] = [currency, 0, 0, 0]
# retrieve balance of specified currency
df = self.balance
df_filtered = df[df['currency'] == currency]['available']
if len(df_filtered) == 0:
# return nil balance if no positive balance was found
return 0.0
else:
# return balance of specified currency (if positive)
if currency in ['EUR', 'GBP', 'USD']:
return float(
self.app.truncate(
float(df[df['currency'] == currency]
['available'].values[0]), 2))
else:
return float(
self.app.truncate(
float(df[df['currency'] == currency]
['available'].values[0]), 4))
else:
if self.mode == 'live':
# if config is provided and live connect to Coinbase Pro account portfolio
model = CBAuthAPI(self.app.getAPIKey(),
self.app.getAPISecret(),
self.app.getAPIPassphrase(),
self.app.getAPIURL())
if currency == '':
# retrieve all balances
return model.getAccounts()[[
'currency', 'balance', 'hold', 'available'
]]
else:
df = model.getAccounts()
# retrieve balance of specified currency
df_filtered = df[df['currency'] == currency]['available']
if len(df_filtered) == 0:
# return nil balance if no positive balance was found
return 0.0
else:
# return balance of specified currency (if positive)
if currency in ['EUR', 'GBP', 'USD']:
return float(
self.app.truncate(
float(df[df['currency'] == currency]
['available'].values[0]), 2))
else:
return float(
self.app.truncate(
float(df[df['currency'] == currency]
['available'].values[0]), 4))
else:
# return dummy balances
if currency == '':
# retrieve all balances
return self.balance
else:
# replace QUOTE and BASE placeholders
if currency in ['EUR', 'GBP', 'USD']:
self.balance = self.balance.replace('QUOTE', currency)
elif currency in ['BCH', 'BTC', 'ETH', 'LTC', 'XLM']:
self.balance = self.balance.replace('BASE', currency)
if self.balance.currency[self.balance.currency.isin(
[currency])].empty == True:
self.balance.loc[len(
self.balance)] = [currency, 0, 0, 0]
# retrieve balance of specified currency
df = self.balance
df_filtered = df[df['currency'] == currency]['available']
if len(df_filtered) == 0:
# return nil balance if no positive balance was found
return 0.0
else:
# return balance of specified currency (if positive)
if currency in ['EUR', 'GBP', 'USD']:
return float(
self.app.truncate(
float(df[df['currency'] == currency]
['available'].values[0]), 2))
else:
return float(
self.app.truncate(
float(df[df['currency'] == currency]
['available'].values[0]), 4))
def executeJob(sc, market, granularity, tradingData=pd.DataFrame()):
"""Trading bot job which runs at a scheduled interval"""
global action, iterations, x_since_buy, x_since_sell, last_action, last_df_index
# increment iterations
iterations = iterations + 1
if is_sim == 0:
# retrieve the market data
api = PublicAPI()
tradingData = api.getHistoricalData(market, granularity)
# analyse the market data
tradingDataCopy = tradingData.copy()
technicalAnalysis = TechnicalAnalysis(tradingDataCopy)
technicalAnalysis.addAll()
df = technicalAnalysis.getDataFrame()
if len(df) != 300:
# data frame should have 300 rows, if not retry
print('error: data frame length is < 300 (' + str(len(df)) + ')')
logging.error('error: data frame length is < 300 (' + str(len(df)) +
')')
s.enter(300, 1, executeJob, (sc, market, granularity))
if is_sim == 1:
# with a simulation df_last will iterate through data
df_last = df.iloc[iterations - 1:iterations]
else:
# df_last contains the most recent entry
df_last = df.tail(1)
ema12gtema26 = bool(df_last['ema12gtema26'].values[0])
ema12gtema26co = bool(df_last['ema12gtema26co'].values[0])
macdgtsignal = bool(df_last['macdgtsignal'].values[0])
macdgtsignalco = bool(df_last['macdgtsignalco'].values[0])
ema12ltema26 = bool(df_last['ema12ltema26'].values[0])
ema12ltema26co = bool(df_last['ema12ltema26co'].values[0])
macdltsignal = bool(df_last['macdltsignal'].values[0])
macdltsignalco = bool(df_last['macdltsignalco'].values[0])
obv = float(df_last['obv'].values[0])
obv_pc = float(df_last['obv_pc'].values[0])
# criteria for a buy signal
if ((ema12gtema26co == True and macdgtsignal == True and obv_pc > 0.1) or
(ema12gtema26 == True and macdgtsignal == True and obv_pc > 0.1
and x_since_buy > 0 and x_since_buy <= 2)) and last_action != 'BUY':
action = 'BUY'
# criteria for a sell signal
elif (ema12ltema26co == True
and macdltsignal == True) and last_action not in ['', 'SELL']:
action = 'SELL'
# anything other than a buy or sell, just wait
else:
action = 'WAIT'
# polling is every 5 minutes (even for hourly intervals), but only process once per interval
if (last_df_index != df_last.index.format()):
ts_text = str(df_last.index.format()[0])
price_text = 'Price: ' + str(
truncate(float(df_last['close'].values[0]), 2))
ema_text = compare(df_last['ema12'].values[0],
df_last['ema26'].values[0], 'EMA12/26')
macd_text = compare(df_last['macd'].values[0],
df_last['signal'].values[0], 'MACD')
obv_text = compare(df_last['obv_pc'].values[0], 0, 'OBV %')
counter_text = '[I:' + str(iterations) + ',B:' + str(
x_since_buy) + ',S:' + str(x_since_sell) + ']'
ema_co_prefix = ''
ema_co_suffix = ''
if ema12gtema26co == True or ema12ltema26co == True:
ema_co_prefix = '* '
ema_co_suffix = ' *'
macd_co_prefix = ''
macd_co_suffix = ''
if macdgtsignalco == True or macdltsignalco == True:
macd_co_prefix = '* '
macd_co_suffix = ' *'
if is_verbose == 0:
output_text = ts_text + ' | ' + price_text + ' | ' + ema_co_prefix + ema_text + ema_co_suffix + ' | ' + macd_co_prefix + macd_text + macd_co_suffix + ' | ' + obv_text + ' | ' + action + ' ' + counter_text
logging.debug(output_text)
print(output_text)
else:
logging.debug('-- Iteration: ' + str(iterations) + ' --')
logging.debug('-- Since Last Buy: ' + str(x_since_buy) + ' --')
logging.debug('-- Since Last Sell: ' + str(x_since_sell) + ' --')
logging.debug('price: ' +
str(truncate(float(df_last['close'].values[0]), 2)))
logging.debug('ema12: ' +
str(truncate(float(df_last['ema12'].values[0]), 2)))
logging.debug('ema26: ' +
str(truncate(float(df_last['ema26'].values[0]), 2)))
logging.debug('ema12gtema26co: ' + str(ema12gtema26co))
logging.debug('ema12gtema26: ' + str(ema12gtema26))
logging.debug('ema12ltema26co: ' + str(ema12ltema26co))
logging.debug('ema12ltema26: ' + str(ema12ltema26))
logging.debug('macd: ' +
str(truncate(float(df_last['macd'].values[0]), 2)))
logging.debug('signal: ' +
str(truncate(float(df_last['signal'].values[0]), 2)))
logging.debug('macdgtsignal: ' + str(macdgtsignal))
logging.debug('macdltsignal: ' + str(macdltsignal))
logging.debug('obv: ' + str(obv))
logging.debug('obv_pc: ' + str(obv_pc) + '%')
logging.debug('action: ' + action)
# informational output on the most recent entry
print('')
print(
'================================================================================'
)
txt = ' Iteration : ' + str(iterations)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Since Last Buy : ' + str(x_since_buy)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Since Last Sell : ' + str(x_since_sell)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Timestamp : ' + str(df_last.index.format()[0])
print('|', txt, (' ' * (75 - len(txt))), '|')
print(
'--------------------------------------------------------------------------------'
)
txt = ' EMA12 : ' + str(
truncate(float(df_last['ema12'].values[0]), 2))
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' EMA26 : ' + str(
truncate(float(df_last['ema26'].values[0]), 2))
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Crossing Above : ' + str(ema12gtema26co)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Currently Above : ' + str(ema12gtema26)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Crossing Below : ' + str(ema12ltema26co)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Currently Below : ' + str(ema12ltema26)
print('|', txt, (' ' * (75 - len(txt))), '|')
if (ema12gtema26 == True and ema12gtema26co == True):
txt = ' Condition : EMA12 is currently crossing above EMA26'
elif (ema12gtema26 == True and ema12gtema26co == False):
txt = ' Condition : EMA12 is currently above EMA26 and has crossed over'
elif (ema12ltema26 == True and ema12ltema26co == True):
txt = ' Condition : EMA12 is currently crossing below EMA26'
elif (ema12ltema26 == True and ema12ltema26co == False):
txt = ' Condition : EMA12 is currently below EMA26 and has crossed over'
else:
txt = ' Condition : -'
print('|', txt, (' ' * (75 - len(txt))), '|')
print(
'--------------------------------------------------------------------------------'
)
txt = ' MACD : ' + str(
truncate(float(df_last['macd'].values[0]), 2))
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Signal : ' + str(
truncate(float(df_last['signal'].values[0]), 2))
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Currently Above : ' + str(macdgtsignal)
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' Currently Below : ' + str(macdltsignal)
print('|', txt, (' ' * (75 - len(txt))), '|')
if (macdgtsignal == True and macdgtsignalco == True):
txt = ' Condition : MACD is currently crossing above Signal'
elif (macdgtsignal == True and macdgtsignalco == False):
txt = ' Condition : MACD is currently above Signal and has crossed over'
elif (macdltsignal == True and macdltsignalco == True):
txt = ' Condition : MACD is currently crossing below Signal'
elif (macdltsignal == True and macdltsignalco == False):
txt = ' Condition : MACD is currently below Signal and has crossed over'
else:
txt = ' Condition : -'
print('|', txt, (' ' * (75 - len(txt))), '|')
print(
'--------------------------------------------------------------------------------'
)
txt = ' OBV : ' + str(truncate(obv, 4))
print('|', txt, (' ' * (75 - len(txt))), '|')
txt = ' OBV Change : ' + str(obv_pc) + '%'
print('|', txt, (' ' * (75 - len(txt))), '|')
if (obv_pc >= 2):
txt = ' Condition : Large positive volume changes'
elif (obv_pc < 2 and obv_pc >= 0):
txt = ' Condition : Positive volume changes'
else:
txt = ' Condition : Negative volume changes'
print('|', txt, (' ' * (75 - len(txt))), '|')
print(
'--------------------------------------------------------------------------------'
)
txt = ' Action : ' + action
print('|', txt, (' ' * (75 - len(txt))), '|')
print(
'================================================================================'
)
if last_action == 'BUY':
x_since_buy = x_since_buy + 1
elif last_action == 'SELL':
x_since_sell = x_since_sell + 1
# if a buy signal
if action == 'BUY':
# increment x since buy
x_since_buy = x_since_buy + 1
# reset x since sell
x_since_sell = 0
# if live
if is_live == 1:
if is_verbose == 0:
logging.info(ts_text + ' | ' + market + ' ' +
str(granularity) + ' | ' + price_text +
' | BUY')
print(ts_text, '|', market, granularity, '|', price_text,
'| BUY')
else:
print(
'--------------------------------------------------------------------------------'
)
print(
'| *** Executing LIVE Buy Order *** |'
)
print(
'--------------------------------------------------------------------------------'
)
# connect to coinbase pro api (authenticated)
model = AuthAPI(config['api_key'], config['api_secret'],
config['api_pass'], config['api_url'])
# execute a live market buy
resp = model.marketBuy(market,
float(account.getBalance(fiatMarket)))
logging.info(resp)
#logging.info('attempt to buy ' + resp['specified_funds'] + ' (' + resp['funds'] + ' after fees) of ' + resp['product_id'])
# if not live
else:
if is_verbose == 0:
logging.info(ts_text + ' | ' + market + ' ' +
str(granularity) + ' | ' + price_text +
' | BUY')
print(ts_text, '|', market, granularity, '|', price_text,
'| BUY')
else:
print(
'--------------------------------------------------------------------------------'
)
print(
'| *** Executing TEST Buy Order *** |'
)
print(
'--------------------------------------------------------------------------------'
)
#print(df_last[['close','ema12','ema26','ema12gtema26','ema12gtema26co','macd','signal','macdgtsignal','obv','obv_pc']])
# if a sell signal
elif action == 'SELL':
# increment x since buy
x_since_sell = x_since_sell + 1
# reset x since buy
x_since_buy = 0
# if live
if is_live == 1:
if is_verbose == 0:
logging.info(ts_text + ' | ' + market + ' ' +
str(granularity) + ' | ' + price_text +
' | SELL')
print(ts_text, '|', market, granularity, '|', price_text,
'| SELL')
else:
print(
'--------------------------------------------------------------------------------'
)
print(
'| *** Executing LIVE Sell Order *** |'
)
print(
'--------------------------------------------------------------------------------'
)
# connect to Coinbase Pro API live
model = AuthAPI(config['api_key'], config['api_secret'],
config['api_pass'], config['api_url'])
# execute a live market sell
resp = model.marketSell(
market, float(account.getBalance(cryptoMarket)))
logging.info(resp)
#logging.info('attempt to sell ' + resp['size'] + ' of ' + resp['product_id'])
# if not live
else:
if is_verbose == 0:
logging.info(ts_text + ' | ' + market + ' ' +
str(granularity) + ' | ' + price_text +
' | SELL')
print(ts_text, '|', market, granularity, '|', price_text,
'| SELL')
else:
print(
'--------------------------------------------------------------------------------'
)
print(
'| *** Executing TEST Sell Order *** |'
)
print(
'--------------------------------------------------------------------------------'
)
#print(df_last[['close','ema12','ema26','ema12ltema26','ema12ltema26co','macd','signal','macdltsignal','obv','obv_pc']])
# last significant action
if action in ['BUY', 'SELL']:
last_action = action
last_df_index = df_last.index.format()
# if live
if is_live == 1:
# save csv with orders for market that are 'done'
orders = account.getOrders(market, '', 'done')
orders.to_csv('orders.csv', index=False)
if is_sim == 1:
if iterations < 300:
if sim_speed == 'fast':
# fast processing
executeJob(sc, market, granularity, tradingData)
else:
# slow processing
s.enter(1, 1, executeJob,
(sc, market, granularity, tradingData))
else:
# poll every 5 minutes
s.enter(300, 1, executeJob, (sc, market, granularity))
def getOrders(self, market='', action='', status='all'):
"""Retrieves orders either live or simulation
Parameters
----------
market : str, optional
Filters orders by market
action : str, optional
Filters orders by action
status : str
Filters orders by status, defaults to 'all'
"""
# validate market is syntactically correct
self._checkMarketSyntax(market)
if action != '':
# validate action is either a buy or sell
if not action in ['buy', 'sell']:
raise ValueError('Invalid order action.')
# validate status is open, pending, done, active or all
if not status in [
'open', 'pending', 'done', 'active', 'all', 'filled'
]:
raise ValueError('Invalid order status.')
if self.app.getExchange() == 'binance':
if self.mode == 'live':
resp = self.client.get_all_orders(symbol=market)
if len(resp) > 0:
df = pd.DataFrame(resp)
else:
df = pd.DataFrame()
if len(df) == 0:
return pd.DataFrame()
df = df[[
'time', 'symbol', 'side', 'type', 'executedQty',
'cummulativeQuoteQty', 'status'
]]
df.columns = [
'created_at', 'market', 'action', 'type', 'size', 'value',
'status'
]
df['created_at'] = df['created_at'].apply(
lambda x: int(str(x)[:10]))
df['created_at'] = df['created_at'].astype("datetime64[s]")
df['size'] = df['size'].astype(float)
df['value'] = df['value'].astype(float)
df['action'] = df['action'].str.lower()
df['type'] = df['type'].str.lower()
df['status'] = df['status'].str.lower()
df['price'] = df['value'] / df['size']
# pylint: disable=unused-variable
for k, v in df.items():
if k == 'status':
df[k] = df[k].map(self.__convertStatus)
if action != '':
df = df[df['action'] == action]
df = df.reset_index(drop=True)
if status != 'all' and status != '':
df = df[df['status'] == status]
df = df.reset_index(drop=True)
return df
else:
# return dummy orders
if market == '':
return self.orders
else:
if (len(self.orders) > 0):
return self.orders[self.orders['market'] == market]
else:
return pd.DataFrame()
if self.app.getExchange() == 'coinbasepro':
if self.mode == 'live':
# if config is provided and live connect to Coinbase Pro account portfolio
model = CBAuthAPI(self.app.getAPIKey(),
self.app.getAPISecret(),
self.app.getAPIPassphrase(),
self.app.getAPIURL())
# retrieve orders from live Coinbase Pro account portfolio
self.orders = model.getOrders(market, action, status)
return self.orders
else:
# return dummy orders
if market == '':
return self.orders
else:
return self.orders[self.orders['market'] == market]
import json
from models.CoinbasePro import AuthAPI
with open('config.json') as config_file:
config = json.load(config_file)
model = AuthAPI(config['api_key'], config['api_secret'], config['api_pass'],
config['api_url'])
#resp = model.authAPI('GET','orders?status=all')
#print (resp)
#accounts = model.getAccounts()
#print (accounts)
#account = model.getAccount('00000000-0000-0000-0000-000000000000')
#print (account)
orders1 = model.getOrders()
print(orders1)
#orders2 = model.getOrders('BTC-GBP')
#print (orders2)
#orders3 = model.getOrders('BTC-GBP', 'buy')
#print (orders3)
#orders4 = model.getOrders('BTC-GBP', 'buy', 'done')
#print (orders4)
#order = model.marketBuy('BTC-GBP', 100)
