def __init__(self, settings, trading_bot: TradingBot):
self.settings = settings
self.id = self.settings.id
self.last_tick = 0
self.logger = log.setup_custom_logger(
name=settings.id,
log_level=settings.LOG_LEVEL,
logToConsole=settings.LOG_TO_CONSOLE,
logToFile=settings.LOG_TO_FILE)
self.logger.info("#############################")
self.logger.info("############ Start LiveTrading " + settings.id +
" on " + settings.EXCHANGE + " #################")
self.exchange: ExchangeInterface = None
if settings.EXCHANGE == 'bitmex':
self.exchange = BitmexInterface(settings=settings,
logger=self.logger,
on_tick_callback=self.on_tick)
elif settings.EXCHANGE == 'bybit':
self.exchange = ByBitInterface(settings=settings,
logger=self.logger,
on_tick_callback=self.on_tick)
elif settings.EXCHANGE == 'binance':
self.exchange = BinanceInterface(settings=settings,
logger=self.logger,
on_tick_callback=self.on_tick)
else:
self.logger.error("unkown exchange: " + settings.EXCHANGE)
self.alive = False
return
self.alive = True
if self.exchange.is_open():
self.logger.info(" Starting Live Trading Engine for %s " %
self.exchange.symbol)
self.symbolInfo: Symbol = self.exchange.get_instrument()
self.bot: TradingBot = trading_bot
self.bot.prepare(self.logger, self)
# init market data dict to be filled later
self.bars: List[Bar] = []
self.update_bars()
self.account: Account = Account()
self.update_account()
self.bot.reset()
else:
self.alive = False
import math
from typing import List
from kuegi_bot.indicators.indicator import Indicator, get_bar_value, highest, lowest, BarSeries, clean_range
from kuegi_bot.trade_engine import Bar
from kuegi_bot.utils import log
logger = log.setup_custom_logger()
class Data:
def __init__(self, hma, hmasum, inner, inner1, inner2):
self.inner = inner
self.inner1 = inner1
self.inner2 = inner2
self.hmasum = hmasum
self.hma = hma
class HMA(Indicator):
''' Hull Moving Average
HMA[i] = MA( (2*MA(input, period/2) – MA(input, period)), SQRT(period))
'''
def __init__(self, period: int = 15, maType: int = 0):
super().__init__('HMA(' + str(period) + ',' + str(maType) + ')')
self.period = period
self.halfperiod = int(self.period / 2)
self.hmalength = int(math.sqrt(self.period))
self.maType = maType
def on_tick(self, bars: List[Bar]):
def __init__(self, settings, telegram: TelegramBot,
trading_bot: TradingBot):
self.settings = settings
self.id = self.settings.id
self.last_tick = 0
self.logger = log.setup_custom_logger(
name=settings.id,
log_level=settings.LOG_LEVEL,
logToConsole=settings.LOG_TO_CONSOLE,
logToFile=settings.LOG_TO_FILE)
self.telegram_bot = telegram
self.logger.info("#############################")
self.logger.info("############ Start LiveTrading " + settings.id +
" on " + settings.EXCHANGE + " #################")
self.exchange: ExchangeInterface = None
if settings.EXCHANGE == 'bitmex':
self.exchange = BitmexInterface(settings=settings,
logger=self.logger,
on_tick_callback=self.on_tick)
elif settings.EXCHANGE == 'bybit':
self.exchange = ByBitInterface(settings=settings,
logger=self.logger,
on_tick_callback=self.on_tick)
elif settings.EXCHANGE == 'binance':
self.exchange = BinanceInterface(settings=settings,
logger=self.logger,
on_tick_callback=self.on_tick)
elif settings.EXCHANGE == 'phemex':
self.exchange = PhemexInterface(settings=settings,
logger=self.logger,
on_tick_callback=self.on_tick)
else:
self.logger.error("unkown exchange: " + settings.EXCHANGE)
self.alive = False
return
self.alive = True
if self.exchange.is_open():
self.logger.info(" Starting Live Trading Engine for %s " %
self.exchange.symbol)
self.symbolInfo: Symbol = self.exchange.get_instrument()
self.bot: TradingBot = trading_bot
self.bot.prepare(self.logger, self)
# init market data dict to be filled later
self.bars: List[Bar] = []
self.update_bars()
self.account: Account = Account()
self.update_account()
self.bot.reset()
if self.telegram_bot is not None:
pos = "no pos"
if self.account.open_position is not None and self.account.open_position.avgEntryPrice is not None:
pos = "%.2f @ %.2f" % (
self.account.open_position.quantity,
self.account.open_position.avgEntryPrice)
self.telegram_bot.send_log(
"%s loaded, ready to go with %.2f in wallet and pos %s" %
(self.id, self.account.equity, pos))
else:
self.alive = False
stop_all_and_exit()
break
for usedSettings in toRestart:
logger.info("restarting " + usedSettings.id)
sleep(10)
activeThreads.append(
start_bot(botSettings=usedSettings,
telegram=telegram_bot))
write_dashboard(settings.DASHBOARD_FILE)
except Exception as e:
logger.error("exception in main loop:\n " +
traceback.format_exc())
else:
logger.warn("no bots defined. nothing to do")
activeThreads: List[threading.Thread] = []
logger = None
if __name__ == '__main__':
settings = load_settings_from_args()
logger = log.setup_custom_logger("cryptobot",
log_level=settings.LOG_LEVEL,
logToConsole=settings.LOG_TO_CONSOLE,
logToFile=settings.LOG_TO_FILE)
run(settings)
else:
logger = log.setup_custom_logger("cryptobot-pkg")
import traceback
from time import sleep
from kuegi_bot.utils import log
from kuegi_bot.utils.helper import load_settings_from_args
from kuegi_bot.voluba.aggregator import VolubaAggregator
def run(settings):
try:
voluba = VolubaAggregator(logger=logger, settings=settings)
while True:
voluba.aggregate_data()
voluba.serialize_current_data()
sleep(10)
except Exception as e:
logger.error("exception in main loop:\n " + traceback.format_exc())
if __name__ == '__main__':
settings = load_settings_from_args()
logger = log.setup_custom_logger("voluba",
log_level=settings.LOG_LEVEL,
logToConsole=settings.LOG_TO_CONSOLE,
logToFile=settings.LOG_TO_FILE)
run(settings)
from kuegi_bot.exchanges.bitmex.bitmex_interface import BitmexInterface
from kuegi_bot.exchanges.bybit.bybit_interface import ByBitInterface
from kuegi_bot.utils import log
from kuegi_bot.utils.helper import load_settings_from_args
settings = load_settings_from_args()
logger = log.setup_custom_logger("cryptobot",
log_level=settings.LOG_LEVEL,
logToConsole=True,
logToFile=False)
def onTick():
logger.info("got Tick")
''' binance
from binance_f.exception.binanceapiexception import BinanceApiException
from binance_f.model.candlestickevent import Candlestick
from binance_f import RequestClient, SubscriptionClient
from binance_f.model import CandlestickInterval, OrderSide, OrderType, TimeInForce, SubscribeMessageType
request_client = RequestClient(api_key=apiKey, secret_key=apiSecret)
ws = SubscriptionClient(api_key=apiKey,secret_key=apiSecret)
def callback(data_type: SubscribeMessageType, event: any):
if data_type == SubscribeMessageType.RESPONSE:
import logging
import math
import os
import csv
import plotly.graph_objects as go
from typing import List
from datetime import datetime
from kuegi_bot.bots.trading_bot import TradingBot
from kuegi_bot.utils.trading_classes import OrderInterface, Bar, Account, Order, Symbol, AccountPosition
from kuegi_bot.utils import log
logger = log.setup_custom_logger("backtest",
logging.INFO,
logToConsole=True,
logToFile=False)
class SilentLogger(object):
def info(self, *args, **kwargs):
pass
def warn(self, *args, **kwargs):
pass
def error(self, *args, **kwargs):
pass
def debug(self, *args, **kwargs):
pass
import logging
import random
from kuegi_bot.backtest_engine import BackTest
from kuegi_bot.bots.MultiStrategyBot import MultiStrategyBot
from kuegi_bot.bots.strategies.MACross import MACross
from kuegi_bot.bots.strategies.entry_filters import DayOfWeekFilter
from kuegi_bot.bots.strategies.SfpStrat import SfpStrategy
from kuegi_bot.bots.strategies.exit_modules import SimpleBE, ParaTrail, MaxSLDiff
from kuegi_bot.bots.strategies.kuegi_strat import KuegiStrategy
from kuegi_bot.utils.helper import load_bars, prepare_plot, load_funding
from kuegi_bot.utils import log
from kuegi_bot.indicators.kuegi_channel import KuegiChannel
from kuegi_bot.utils.trading_classes import Symbol
logger = log.setup_custom_logger(log_level=logging.INFO)
def plot(bars):
forplot = bars[:]
logger.info("initializing indicators")
indis = [KuegiChannel()]
logger.info("preparing plot")
fig = prepare_plot(forplot, indis)
fig.show()
def backtest(bars):
bots = []
