def __init__(self,setAuto=True):
setup_logger(logger_name="broker", log_file='broker.log')
self.logger = logging.getLogger("broker")
self.afacade = facade.Facade()
#in memory data
self.balances = None
self.openorders = list()
self.submitted_orders = list()
self.active_exchanges = list()
self.selected_exchange = None
if setAuto:
self.set_keys_exchange_file()
try:
all_conf = parse_toml("conf.toml")
except:
self.logger.error("no conf.toml file")
try:
mongo_conf = all_conf["MONGO"]
uri = mongo_conf["uri"]
self.set_mongo(uri)
self.using_mongo = True
except:
self.using_mongo = False
self.logger.error("could not set mongo")
self.starttime = datetime.datetime.utcnow()
def __init__(self, abroker, exchange):
threading.Thread.__init__(self)
setup_logger(logger_name=__name__, log_file='broker.log')
self.logger = logging.getLogger(__name__)
#config = agent_config()["AGENT"]
#m = config["market"]
market = "LTC_BTC"
self.agent_id = "agent" #config["agentid"]
self.threadID = "thread-" + self.agent_id
self.afacade = facade.Facade()
self.abroker = abroker
nom,denom = market.split('_')
#TODO config
self.e = exchange
#self.market = models.get_market(nom,denom,self.e)
self.market = market
self.rho = 0.1
#TODO broker already keeps track
self.openorders = list()
self.positions = list()
self.round_precision = 8
#pip paramter for ordering
self.pip = 0.0000001
self.logger.info("agent inited")
def __init__(self,
base_url=API_BASE,
symbol=None,
login=None,
password=None,
otpToken=None,
apiKey=None,
apiSecret=None,
orderIDPrefix='mm_bitmex_'):
setup_logger(logger_name=__name__, log_file='bitmex.log')
self.logger = logging.getLogger(__name__)
self.logger.info("init bitmex")
self.base_url = base_url
self.symbol = symbol
self.token = None
self.login = login
self.password = password
self.otpToken = otpToken
self.apiKey = apiKey
self.apiSecret = apiSecret
if len(orderIDPrefix) > 13:
raise ValueError(
"settings.ORDERID_PREFIX must be at most 13 characters long!")
self.orderIDPrefix = orderIDPrefix
# Prepare HTTPS session
self.session = requests.Session()
# These headers are always sent
self.session.headers.update({'user-agent': 'easy-data-scripts'})
def __init__(self, abroker):
threading.Thread.__init__(self)
setup_logger(logger_name="Feeder", log_file='feeder.log')
self.log = logging.getLogger("Feeder")
self.abroker = abroker
self.log.info("init feeder")
self.redisclient = abroker.get_redis()
#TODO in config
mex_sym = mex.instrument_btc_perp
self.mex_sym = mex_sym
def __init__(self):
setup_logger(logger_name=__name__, log_file='broker.log')
self.logger = logging.getLogger(__name__)
self.submitted_orders = 0
self.canceled_orders = 0
#facade tracks list of orders and their status
self.orders = list()
self.clients = {}
def __init__(self, abroker, mex_sym):
threading.Thread.__init__(self)
setup_logger(logger_name="Strategy", log_file='strat.log')
self.log = logging.getLogger("Strategy")
self.abroker = abroker
self.log.info("init strategy %s" % (mex_sym))
self.mex_sym = mex_sym
self.redis_client = redis.Redis(host='localhost', port=6379)
self.alive_flag = True
def __init__(self, abroker, mex_sym, order_qty, zoff):
setup_logger(logger_name=__name__, log_file=__name__ + '.log')
self.log = logging.getLogger(__name__)
self.log.info('marb strategy')
remove_loggers()
# init data
self.book_mex = None
self.pos_qty = 0
self.zoff = zoff # the offset in $
self.diff_cancel = 1.0 # cancel if diff is larger than this
self.order_qty = order_qty
super().__init__(abroker, mex_sym)
def __init__(self, response):
setup_logger(logger_name=__name__, log_file=__name__ + '.log')
self.logger = logging.getLogger(__name__)
self.self.loggerdebug("init binance")
self.code = 0
try:
json_res = response.json()
except ValueError:
self.message = 'Invalid JSON error message from Binance: {}'.format(
response.text)
else:
self.code = json_res['code']
self.message = json_res['msg']
self.status_code = response.status_code
self.response = response
self.request = getattr(response, 'request', None)
def __init__(self, key=None, secret=None, url=None):
setup_logger(logger_name="DeribitWrapper", log_file='DeribitWrapper.log')
self.logger = logging.getLogger("DeribitWrapper")
self.key = key
self.secret = secret
self.session = requests.Session()
#connect ws?
#self.ws = DeribitWebsocket()
#self.ws.connect()
if url:
self.url = url
else:
self.url = "https://www.deribit.com"
requests_log = logging.getLogger("requests.packages.urllib3")
requests_log.setLevel(logging.WARNING)
def __init__(self):
self.client = RestClient('', '')
self.table = {}
#self.logger = logging.getLogger('root')
self.__reset()
setup_logger(__name__, 'DeribitWebsocket.log')
self.logger = logging.getLogger(__name__)
# disable all loggers from different files
logging.getLogger('asyncio').setLevel(logging.ERROR)
logging.getLogger('asyncio.coroutines').setLevel(logging.ERROR)
logging.getLogger('websockets.server').setLevel(logging.ERROR)
logging.getLogger('websockets.protocol').setLevel(logging.ERROR)
logging.getLogger('websocket-client').setLevel(logging.ERROR)
requests_log = logging.getLogger("requests.packages.urllib3")
requests_log.setLevel(logging.WARNING)
def run():
setup_logger(logger_name="test", log_file='test.log')
logger = logging.getLogger("test")
# Instantiating the WS will make it connect. Be sure to add your api_key/api_secret.
ws = BitMEXWebsocket(endpoint="https://testnet.bitmex.com/api/v1",
symbol="XBTUSD",
api_key=None,
api_secret=None)
logger.info("Instrument data: %s" % ws.get_instrument())
# Run forever
while (ws.ws.sock.connected):
logger.info("Ticker: %s" % ws.get_ticker())
if ws.api_key:
logger.info("Funds: %s" % ws.funds())
logger.info("Market Depth: %s" % ws.market_depth())
logger.info("Recent Trades: %s\n\n" % ws.recent_trades())
sleep(10)
def __init__(self,
symbol,
api_key=None,
api_secret=None,
endpoint=endpoint_V1):
'''Connect to the websocket and initialize data stores.'''
setup_logger(__name__, 'strategy.log')
self.logger = logging.getLogger(__name__)
self.logger.debug("bitmex - initializing WebSocket.")
self.endpoint = endpoint
self.symbol = symbol
self.msg_processed = 0
if api_key is not None and api_secret is None:
raise ValueError('api_secret is required if api_key is provided')
if api_key is None and api_secret is not None:
raise ValueError('api_key is required if api_secret is provided')
self.api_key = api_key
self.api_secret = api_secret
self.data = {}
self.keys = {}
self.exited = False
#assume one symbol for now
self.orderbook = {}
self.msg_count = 0
self.last_msg = datetime.now()
#define topics to subscribe to
#self.symbolSubs = [TOPIC_execution, TOPIC_instrument, TOPIC_order, TOPIC_orderBook10, TOPIC_position, TOPIC_quote, TOPIC_trade]
#account_sub_topics = {TOPIC_margin, TOPIC_position, TOPIC_order, TOPIC_orderBook10}
#symbol_topics = {TOPIC_instrument, TOPIC_trade, TOPIC_quote}
#data loop
#1 subscribe
#2 wait for subscription success
#3 handle update (could e.g. ignore updates)
#self.symbolSubs = [TOPIC_orderBookL2_25]
#self.symbolSubs = [TOPIC_instrument, TOPIC_orderBook10, TOPIC_quote, TOPIC_trade]
self.symbolSubs = [
TOPIC_instrument, TOPIC_orderBookL2_25, TOPIC_quote, TOPIC_trade
]
self.genericSubs = [TOPIC_margin]
symbol_subscriptions = [
sub + ':' + self.symbol for sub in self.symbolSubs
]
self.subscriptions = symbol_subscriptions + self.genericSubs
self.logger.info("subscriptions %s" % str(self.subscriptions))
self.all_topics = self.symbolSubs + self.genericSubs
self.subscribed = list()
# We can subscribe right in the connection querystring, so let's build that.
# Subscribe to all pertinent endpoints
wsURL = self.__get_url()
self.logger.info("Connecting to %s" % wsURL)
self.__connect(wsURL, symbol)
self.logger.info('Connected to WS.')
# Connected. Wait for partials
self.subscribe_topic(TOPIC_orderBook10)
self.logger.info('Wait for initial data')
self.got_init_data = False
#TODO
#self.__wait_for_subscription()
#self.__wait_for_symbol(symbol)
#if api_key:
#self.__wait_for_account()
self.got_init_data = True
self.logger.info('Got all market data. Starting.')
def __init__(self):
setup_logger(logger_name=__name__, log_file='broker.log')
self.logger = logging.getLogger(__name__)
self.clients = {}
def __init__(self, arch):
setup_logger(logger_name=__name__, log_file=__name__ + '.log')
self.logger = logging.getLogger(__name__)
super().__init__(arch, exc.BINANCE)
def __init__(self,
setAuto=True,
setMongo=True,
setRedis=True,
initFeeder=True):
setup_logger(logger_name="brokerservice", log_file='brokerservice.log')
self.logger = logging.getLogger("brokerservice")
self.afacade = facader.FacadeRaw()
#TODO
#in memory data
self.balances = None
#self.openorders = list()
#self.submitted_orders = list()
#self.active_exchanges = list()
#self.selected_exchange = None
conf_file = "conf.toml"
wdir = self.get_workingdir()
keys_filename = standard_conf_file
path_file_conf = wdir + "/" + keys_filename
if setAuto:
self.set_keys_exchange_file()
if not os.path.exists(path_file_conf):
self.logger.error("no toml file. expected path %s" %
str(path_file_conf))
else:
try:
all_conf = parse_toml(path_file_conf)
except:
self.logger.error("config file %s not properly formatted" %
str(conf_file))
if setMongo:
try:
mongo_conf = all_conf["MONGO"]
self.logger.info("mongo conf %s" % str(mongo_conf))
uri = mongo_conf["uri"]
self.set_mongo(uri)
self.using_mongo = True
except Exception as e:
self.using_mongo = False
self.logger.error(
"could not set mongo. wrong configuration or config file")
self.logger.error(str(e))
self.starttime = datetime.datetime.utcnow()
#TODO conf
#init feeder stream
if setRedis:
self.logger.info(all_conf)
try:
redis_conf = all_conf["REDIS"]
host = redis_conf["host"]
port = redis_conf["port"]
self.redis_client = redis.Redis(host=host, port=port)
except Exception as e:
self.logger.error("could not set redis %s %s" %
(str(host), str(port)))
self.logger.error(str(e))
#self.init_bitmex_ws(self.redis_client)
#init feeder thread
if initFeeder:
f = Feeder(self)
f.start()
f.join()
