class Ayam:
def __init__(self):
self.ig_service = IGService(username=config2.username,
password=config2.password,
api_key=config2.api_key,
acc_type=config2.acc_type)
self.ig_service.create_session()
def create_position(self, epic, direction, objectif, currency_info, qty):
otc = self.ig_service.create_open_position(
direction=direction,
currency_code=currency_info,
order_type="MARKET",
size=qty,
force_open=True,
expiry="-",
guaranteed_stop=False,
epic=epic,
limit_level=objectif,
level=None,
limit_distance=None,
quote_id=None,
stop_distance=None,
stop_level=None,
)
return otc
class IGStore(with_metaclass(MetaSingleton, object)):
'''
The IG store class should inherit from the the metaclass and add some
extensions to it.
'''
BrokerCls = None # broker class will autoregister
DataCls = None # data class will auto register
params = (
('token', ''),
('account', ''),
('usr', ''),
('pwd', ''),
('currency_code', 'GBP'), #The currency code of the account
('practice', True),
('account_tmout', 10.0), # account balance refresh timeout
)
_ENVPRACTICE = 'DEMO'
_ENVLIVE = 'LIVE'
_ORDEREXECS = {
bt.Order.Market: 'MARKET',
bt.Order.Limit: 'LIMIT',
bt.Order.Stop: 'STOP',
bt.Order.StopLimit: 'TODO',
}
_GRANULARITIES = 'TODO - NEEDED FOR HISTORICAL'
@classmethod
def getdata(cls, *args, **kwargs):
'''Returns ``DataCls`` with args, kwargs'''
return cls.DataCls(*args, **kwargs)
@classmethod
def getbroker(cls, *args, **kwargs):
'''Returns broker with *args, **kwargs from registered ``BrokerCls``'''
return cls.BrokerCls(*args, **kwargs)
def __init__(self):
super(IGStore, self).__init__()
self.notifs = collections.deque() # store notifications for cerebro
self._env = None # reference to cerebro for general notifications
self.broker = None # broker instance
self.datas = list() # datas that have registered over start
self._orders = collections.OrderedDict() # map order.ref to oid
self._ordersrev = collections.OrderedDict() # map oid to order.ref
self._transpend = collections.defaultdict(collections.deque)
self._oenv = self._ENVPRACTICE if self.p.practice else self._ENVLIVE
self.igapi = IGService(self.p.usr, self.p.pwd, self.p.token,
self._oenv)
self.igapi.create_session()
self.igss = Streamer(ig_service=self.igapi)
self.ig_session = self.igss.create_session()
self.igss.connect(self.p.account)
#Work with JSON rather than Pandas for better backtrader integration
self.igapi.return_dataframe = False
self._cash = 0.0
self._value = 0.0
self.pull_cash_and_value()
self._evt_acct = threading.Event()
def broker_threads(self):
'''
Setting up threads and targets for broker related notifications.
'''
self.q_account = queue.Queue()
kwargs = {'q': self.q_account}
self.q_account.put(True) # force an immediate update
t = threading.Thread(target=self._t_account)
t.daemon = True
t.start()
t = threading.Thread(target=self._t_account_events, kwargs=kwargs)
t.daemon = True
t.start()
self.q_ordercreate = queue.Queue()
t = threading.Thread(target=self._t_order_create)
t.daemon = True
t.start()
self.q_orderclose = queue.Queue()
t = threading.Thread(target=self._t_order_cancel)
t.daemon = True
t.start()
# Wait once for the values to be set
self._evt_acct.wait(self.p.account_tmout)
def pull_cash_and_value(self):
'''
Method to set the initial cash and value before streaming updates start.
'''
accounts = self.igapi.fetch_accounts()
for account in accounts['accounts']:
if self.p.account == account['accountId']:
self._cash = account['balance']['available']
self._value = account['balance']['balance']
def get_cash(self):
#TODO - Check where we
return self._cash
def get_notifications(self):
'''Return the pending "store" notifications'''
self.notifs.append(None) # put a mark / threads could still append
return [x for x in iter(self.notifs.popleft, None)]
def get_positions(self):
#TODO - Get postion info from returned object.
positions = self.igapi.fetch_open_positions()
return positions['positions']
def get_value(self):
return self._value
def put_notification(self, msg, *args, **kwargs):
self.notifs.append((msg, args, kwargs))
def start(self, data=None, broker=None):
# Datas require some processing to kickstart data reception
if data is None and broker is None:
self.cash = None
return
if data is not None:
self._env = data._env
# For datas simulate a queue with None to kickstart co
self.datas.append(data)
if self.broker is not None:
self.broker.data_started(data)
elif broker is not None:
self.broker = broker
self.streaming_events()
self.broker_threads()
def stop(self):
# signal end of thread
if self.broker is not None:
self.q_ordercreate.put(None)
self.q_orderclose.put(None)
self.q_account.put(None)
'''
Loads of methods to add in-between
'''
def _t_account(self):
#TODO
'''
This is a thread with a queue that will extract data as it comes in
I need to pass the relavant account info here after subscribing to
the account information through lightstreamer
'''
while True:
try:
msg = self.q_account.get(timeout=self.p.account_tmout)
if msg is None:
break # end of thread
elif type(
msg
) != bool: #Check it is not the true value at the start of the queue... TODO improve this
try:
self._cash = float(msg["AVAILABLE_CASH"])
self._value = float(msg["EQUITY"])
except KeyError:
pass
except queue.Empty: # tmout -> time to refresh
pass
self._evt_acct.set()
def order_create(self, order, stopside=None, takeside=None, **kwargs):
'''
additional kwargs
expiry: Sting, default = 'DFB' Other examples could be 'DEC-14'. Check
the instrument details through IG to find out the correct expiry.
guaranteed_stop: Bool, default = False. Sets whether or not to use a
guranteed stop.
time_in_force: String. Must be either 'GOOD_TILL_CANCELLED' or "GOOD_TILL_DATE"
good_till_date: Datetime object. Must be provided is "GOOD_TILL_DATE" is set.
'''
okwargs = dict()
okwargs['currency_code'] = self.p.currency_code
#okwargs['dealReference'] = order.ref
okwargs['epic'] = order.data._dataname
#Size must be positive for both buy and sell orders
okwargs['size'] = abs(order.created.size)
okwargs['direction'] = 'BUY' if order.isbuy() else 'SELL'
okwargs['order_type'] = self._ORDEREXECS[order.exectype]
#TODO FILL_OR_KILL
#okwargs['timeInForce'] = 'FILL_OR_KILL'
okwargs['force_open'] = "false"
#Filler - required arguments can update later if Limit order is required
okwargs['level'] = order.created.price
okwargs['limit_level'] = None
okwargs['limit_distance'] = None
okwargs['stop_level'] = None
okwargs['stop_distance'] = None
#Allow users to set the expiry through kwargs
if 'expiry' in kwargs:
okwargs['expiry'] = kwargs["expiry"]
else:
okwargs['expiry'] = 'DFB'
#Allow users to set the a guaranteed stop
#Convert from boolean value to string.
if 'guaranteed_stop' in kwargs:
if kwargs['guaranteed_stop'] == True:
okwargs['guaranteed_stop'] = "true"
elif kwargs['guaranteed_stop'] == False:
okwargs['guaranteed_stop'] = "false"
else:
raise ValueError(
'guaranteed_stop must be a boolean value: "{}" '
'was entered'.format(kwargs['guaranteed_stop']))
else:
okwargs['guaranteed_stop'] = "false"
#Market orders use an 'order_type' keyword. Limit and stop orders use 'type'
if order.exectype == bt.Order.Market:
okwargs['quote_id'] = None
okwargs[
'level'] = None #IG Does not allow a level to be set on market orders
if order.exectype in [bt.Order.Stop, bt.Order.Limit]:
#Allow passing of a timeInForce kwarg
if 'time_in_force' in kwargs:
okwargs['time_in_force'] = kwargs['time_in_force']
if kwargs['time_in_force'] == 'GOOD_TILL_DATE':
if 'good_till_date' in kwargs:
#Trading_IG will do a datetime conversion
okwargs['good_till_date'] = kwargs['good_till_date']
else:
raise ValueError(
'If timeInForce == GOOD_TILL_DATE, a '
'goodTillDate datetime kwarg must be provided.')
else:
okwargs['time_in_force'] = 'GOOD_TILL_CANCELLED'
if order.exectype == bt.Order.StopLimit:
#TODO
okwargs['lowerBound'] = order.created.pricelimit
okwargs['upperBound'] = order.created.pricelimit
if order.exectype == bt.Order.StopTrail:
# TODO need to figure out how to get the stop distance and increment
# from the trail amount.
# print('order trail amount: {}'.format(order.trailamount))
okwargs['stop_distance'] = order.trailamount
#okwargs['trailingStopIncrement'] = 'TODO!'
if stopside is not None:
okwargs['stop_level'] = stopside.price
if takeside is not None:
okwargs['limit_level'] = takeside.price
okwargs.update(**kwargs) # anything from the user
self.q_ordercreate.put((
order.ref,
okwargs,
))
return order
def order_cancel(self, order):
self.q_orderclose.put(order.ref)
return order
def _t_order_cancel(self):
while True:
oref = self.q_orderclose.get()
if oref is None:
break
oid = self._orders.get(oref, None)
if oid is None:
continue # the order is no longer there
try:
o = self.igapi.delete_working_order(oid)
except Exception as e:
continue # not cancelled - FIXME: notify
self.broker._cancel(oref)
def _t_order_create(self):
while True:
msg = self.q_ordercreate.get()
if msg is None:
break
oref, okwargs = msg
# Check to see if it is a market order or working order.
# Market orders have an 'order_type' kwarg. Working orders
# use the 'type' kwarg for setting stop or limit
if okwargs['order_type'] == 'MARKET':
try:
#NOTE The IG API will confirm the deal automatically with the
#create_open_position call. Therefore if no error is returned here
#Then it was accepted and open.
o = self.igapi.create_open_position(**okwargs)
except Exception as e:
self.put_notification(e)
self.broker._reject(oref)
return
else:
# print('Creating Working Order')
try:
o = self.igapi.create_working_order(**okwargs)
except Exception as e:
print(e)
self.put_notification(e)
self.broker._reject(oref)
return
# Ids are delivered in different fields and all must be fetched to
# match them (as executions) to the order generated here
_o = {'dealId': None}
oids = list()
oids.append(o['dealId'])
#print('_t_order_create Deal ID = {}'.format(o['dealId']))
if o['dealStatus'] == 'REJECTED':
self.broker._reject(oref)
self.put_notification(o['reason'])
if not oids:
self.broker._reject(oref)
return
self._orders[oref] = oids[0]
#Send the summission notification
#TODO Shouldn't this come earlier????
self.broker._submit(oref)
if okwargs['order_type'] == 'MARKET':
self.broker._accept(oref) # taken immediately
self.broker._fill(oref, o['size'], o['level'],
okwargs['order_type'])
for oid in oids:
self._ordersrev[oid] = oref # maps ids to backtrader order
def streaming_account(self, tmout=None):
'''
Added by me to create a subscription to account information such as
balance, equity funds, margin.
'''
q = queue.Queue()
kwargs = {'q': q, 'tmout': tmout}
t = threading.Thread(target=self._t_account_listener, kwargs=kwargs)
t.daemon = True
t.start()
t = threading.Thread(target=self._t_account_events, kwargs=kwargs)
t.daemon = True
t.start()
return q
def _t_account_events(self, q, tmout=None):
'''
Thread to create the subscription to account events.
Here we create a merge subscription for lightstreamer.
'''
self.igss.set_account_q(q)
# Making an other Subscription in MERGE mode
subscription_account = Subscription(
mode="MERGE",
items=['ACCOUNT:' + self.p.account],
fields=["AVAILABLE_CASH", "EQUITY"],
)
# #adapter="QUOTE_ADAPTER")
# Adding the "on_balance_update" function to Subscription
subscription_account.addlistener(self.igss.on_account_update)
# Registering the Subscription
sub_key_account = self.igss.ls_client.subscribe(subscription_account)
def streaming_events(self, tmout=None):
pass
def streaming_prices(self, dataname, tmout=None):
q = queue.Queue()
kwargs = {'q': q, 'dataname': dataname, 'tmout': tmout}
t = threading.Thread(target=self._t_streaming_prices, kwargs=kwargs)
t.daemon = True
t.start()
return q
def _t_streaming_prices(self, dataname, q, tmout):
'''
Target for the streaming prices thread. This will setup the streamer.
'''
if tmout is not None:
_time.sleep(tmout)
self.igss.set_price_q(q, dataname)
#igss = Streamer(q, ig_service=self.igapi)
#ig_session = igss.create_session()
#igss.connect(self.p.account)
epic = 'CHART:' + dataname + ':TICK'
# Making a new Subscription in MERGE mode
subcription_prices = Subscription(
mode="DISTINCT",
items=[epic],
fields=["UTM", "BID", "OFR", "TTV", "LTV"],
)
#adapter="QUOTE_ADAPTER")
# Adding the "on_price_update" function to Subscription
subcription_prices.addlistener(self.igss.on_prices_update)
sub_key_prices = self.igss.ls_client.subscribe(subcription_prices)
