def open_orders(self, is_new_bar, directionFilter, bars, account, open_positions, all_open_pos: dict):
if (not is_new_bar) or len(bars) < 5:
return # only open orders on beginning of bar
entriesAllowed = self.entries_allowed(bars)
if not entriesAllowed:
self.logger.info("new entries not allowed by filter")
last_data: Data = self.channel.get_data(bars[2])
data: Data = self.channel.get_data(bars[1])
if data is None:
return
self.logger.info("---- analyzing: %s atr: %.1f buffer: %.1f swings: %s/%s trails: %.1f/%.1f resets:%i/%i" %
(str(datetime.fromtimestamp(bars[0].tstamp)),
data.atr, data.buffer,
("%.1f" % data.longSwing) if data.longSwing is not None else "-",
("%.1f" % data.shortSwing) if data.shortSwing is not None else "-",
data.longTrail, data.shortTrail, data.sinceLongReset, data.sinceShortReset))
if last_data is not None and \
data.shortSwing is not None and data.longSwing is not None and \
(not self.delayed_entry or (last_data.shortSwing is not None and last_data.longSwing is not None)):
swing_range = data.longSwing - data.shortSwing
atr = clean_range(bars, offset=0, length=self.channel.max_look_back * 2)
if atr * self.min_channel_size_factor < swing_range < atr * self.max_channel_size_factor:
risk = self.risk_factor
longEntry = self.symbol.normalizePrice(max(data.longSwing, bars[0].high), roundUp=True)
shortEntry = self.symbol.normalizePrice(min(data.shortSwing, bars[0].low), roundUp=False)
stopLong = self.symbol.normalizePrice(max(data.shortSwing, data.longTrail), roundUp=False)
stopShort = self.symbol.normalizePrice(min(data.longSwing, data.shortTrail), roundUp=True)
stopLong = min(stopLong,longEntry - self.min_stop_diff_atr*atr)
stopShort = max(stopShort, shortEntry + self.min_stop_diff_atr*atr)
expectedEntrySplipagePerc = 0.0015 if self.limit_entry_offset_perc is None else 0
expectedExitSlipagePerc = 0.0015
# first check if we should update an existing one
longAmount = self.calc_pos_size(risk=risk, exitPrice=stopLong * (1 - expectedExitSlipagePerc),
entry=longEntry * (1 + expectedEntrySplipagePerc),
atr=data.atr)
shortAmount = self.calc_pos_size(risk=risk, exitPrice=stopShort * (1 + expectedExitSlipagePerc),
entry=shortEntry * (1 - expectedEntrySplipagePerc),
atr=data.atr)
if longEntry < stopLong or shortEntry > stopShort:
self.logger.warn("can't put initial stop above entry")
foundLong = False
foundShort = False
for position in open_positions.values():
if position.status == PositionStatus.PENDING:
if position.amount > 0:
foundLong = True
entry = longEntry
stop = stopLong
entryFac = (1 + expectedEntrySplipagePerc)
exitFac = (1 - expectedExitSlipagePerc)
else:
foundShort = True
entry = shortEntry
stop = stopShort
entryFac = (1 - expectedEntrySplipagePerc)
exitFac = (1 + expectedExitSlipagePerc)
entryBuffer = entry * self.limit_entry_offset_perc * 0.01 if self.limit_entry_offset_perc is not None else None
for order in account.open_orders:
if TradingBot.position_id_from_order_id(order.id) == position.id:
newEntry = position.wanted_entry * (
1 - self.entry_tightening) + entry * self.entry_tightening
newEntry = self.symbol.normalizePrice(newEntry, roundUp=order.amount > 0)
newStop = position.initial_stop * (
1 - self.entry_tightening) + stop * self.entry_tightening
newStop = self.symbol.normalizePrice(newStop, roundUp=order.amount < 0)
amount = self.calc_pos_size(risk=risk, exitPrice=newStop * exitFac,
entry=newEntry * entryFac, atr=data.atr)
if amount * order.amount < 0:
self.logger.warn("updating order switching direction")
changed = False
changed = changed or order.stop_price != newEntry
order.stop_price = newEntry
if self.limit_entry_offset_perc is not None:
newLimit = newEntry - entryBuffer * math.copysign(1, amount)
changed = changed or order.limit_price != newLimit
order.limit_price = newLimit
changed = changed or order.amount != amount
order.amount = amount
if changed:
self.order_interface.update_order(order)
else:
self.logger.info("order didn't change: %s" % order.print_info())
position.initial_stop = newStop
position.amount = amount
position.wanted_entry = newEntry
break
# if len(self.open_positions) > 0:
# return
signalId = self.get_signal_id(bars)
if not foundLong and directionFilter >= 0 and entriesAllowed:
posId = TradingBot.full_pos_id(signalId, PositionDirection.LONG)
entryBuffer = longEntry * self.limit_entry_offset_perc * 0.01 if self.limit_entry_offset_perc is not None else None
self.order_interface.send_order(Order(orderId=TradingBot.generate_order_id(posId, OrderType.ENTRY),
amount=longAmount, stop=longEntry,
limit=longEntry - entryBuffer if entryBuffer is not None else None))
open_positions[posId] = Position(id=posId, entry=longEntry, amount=longAmount, stop=stopLong,
tstamp=bars[0].tstamp)
if not foundShort and directionFilter <= 0 and entriesAllowed:
posId = TradingBot.full_pos_id(signalId, PositionDirection.SHORT)
entryBuffer = shortEntry * self.limit_entry_offset_perc * 0.01 if self.limit_entry_offset_perc is not None else None
self.order_interface.send_order(Order(orderId=TradingBot.generate_order_id(posId, OrderType.ENTRY),
amount=shortAmount, stop=shortEntry,
limit=shortEntry + entryBuffer if entryBuffer is not None else None))
open_positions[posId] = Position(id=posId, entry=shortEntry, amount=shortAmount,
stop=stopShort, tstamp=bars[0].tstamp)
def open_orders(self, is_new_bar, directionFilter, bars, account,
open_positions):
if (not is_new_bar) or len(bars) < 5:
return # only open orders on beginning of bar
if not self.entries_allowed(bars):
self.logger.info(" no entries allowed")
return
atr = clean_range(bars,
offset=0,
length=self.channel.max_look_back * 2)
# test for SFP:
# High > HH der letzten X
# Close < HH der vorigen X
# ? min Wick size?
# initial SL
data: Data = self.channel.get_data(bars[1])
maxLength = min(len(bars), self.range_length)
minRejLength = min(len(bars), self.min_rej_length)
highSupreme = 0
hhBack = 0
hh = bars[2].high
swingHigh = 0
gotHighSwing = False
for idx in range(2, maxLength):
if bars[idx].high < bars[1].high:
highSupreme = idx - 1
if hh < bars[idx].high:
hh = bars[idx].high
hhBack = idx
elif self.min_swing_length < hhBack <= idx - self.min_swing_length:
gotHighSwing = True
swingHigh = hh # confirmed
else:
break
lowSupreme = 0
llBack = 0
ll = bars[2].low
swingLow = 0
gotLowSwing = False
for idx in range(2, maxLength):
if bars[idx].low > bars[1].low:
lowSupreme = idx - 1
if ll > bars[idx].low:
ll = bars[idx].low
llBack = idx
elif self.min_swing_length < llBack <= idx - self.min_swing_length:
gotLowSwing = True
swingLow = ll # confirmed
else:
break
rangeMedian = (bars[maxLength - 1].high + bars[maxLength - 1].low) / 2
alpha = 2 / (maxLength + 1)
for idx in range(maxLength - 2, 0, -1):
rangeMedian = rangeMedian * alpha + (
bars[idx].high + bars[idx].low) / 2 * (1 - alpha)
# SHORT
longSFP = self.entries != 1 and gotHighSwing and bars[
1].close + data.buffer < swingHigh
longRej = self.entries != 2 and bars[1].high > hh > bars[
1].close + data.buffer and highSupreme > minRejLength
# LONG
shortSFP = self.entries != 1 and gotLowSwing and bars[
1].close - data.buffer > swingLow
shortRej = self.entries != 2 and bars[1].low < ll < bars[
1].close - data.buffer and lowSupreme > minRejLength
self.logger.info(
"---- analyzing: %s: %.1f %.1f %.0f | %s %.0f %i or %i %.0f %.0f | %s %.0f %i or %i %.0f %.0f "
% (str(datetime.fromtimestamp(bars[0].tstamp)), data.buffer, atr,
rangeMedian, gotHighSwing, swingHigh, hhBack, highSupreme, hh,
bars[1].high - bars[1].close, gotLowSwing, swingLow, llBack,
lowSupreme, ll, bars[1].close - bars[1].low))
if (longSFP or longRej) and (bars[1].high - bars[1].close) > atr * self.min_wick_fac \
and directionFilter <= 0 and bars[1].high > rangeMedian + atr * self.range_filter_fac \
and bars[1].high - bars[1].close > (bars[1].high - bars[1].low) / 2:
self.__open_position(PositionDirection.SHORT, bars,
swingHigh if gotHighSwing else hh,
open_positions)
if (shortSFP or shortRej) and (bars[1].close - bars[1].low) > atr * self.min_wick_fac \
and directionFilter >= 0 and bars[1].low < rangeMedian - atr * self.range_filter_fac\
and bars[1].close - bars[1].low > (bars[1].high - bars[1].low) / 2:
self.__open_position(PositionDirection.LONG, bars,
swingLow if gotLowSwing else ll,
open_positions)
def open_orders(self, is_new_bar, directionFilter, bars, account, open_positions):
if (not is_new_bar) or len(bars) < 5:
return # only open orders on beginning of bar
if not self.entries_allowed(bars):
self.logger.info(" no entries allowed")
return
atr = clean_range(bars, offset=0, length=self.channel.max_look_back * 2)
risk = self.risk_factor
# test for SFP:
# High > HH der letzten X
# Close < HH der vorigen X
# ? min Wick size?
# initial SL
data: Data = self.channel.get_data(bars[1])
maxLength = min(len(bars), self.range_length)
minRejLength = min(len(bars),self.min_rej_length)
highSupreme = 0
hhBack = 0
hh = bars[2].high
swingHigh = 0
gotHighSwing = False
for idx in range(2, maxLength):
if bars[idx].high < bars[1].high:
highSupreme = idx - 1
if hh < bars[idx].high:
hh = bars[idx].high
hhBack = idx
elif self.min_swing_length < hhBack <= idx - self.min_swing_length:
gotHighSwing = True
swingHigh = hh # confirmed
else:
break
lowSupreme = 0
llBack = 0
ll = bars[2].low
swingLow = 0
gotLowSwing = False
for idx in range(2, maxLength):
if bars[idx].low > bars[1].low:
lowSupreme = idx - 1
if ll > bars[idx].low:
ll = bars[idx].low
llBack = idx
elif self.min_swing_length < llBack <= idx - self.min_swing_length:
gotLowSwing = True
swingLow = ll # confirmed
else:
break
rangeMedian = (bars[maxLength - 1].high + bars[maxLength - 1].low) / 2
alpha = 2 / (maxLength + 1)
for idx in range(maxLength - 2, 0, -1):
rangeMedian = rangeMedian * alpha + (bars[idx].high + bars[idx].low) / 2 * (1 - alpha)
expectedEntrySplipagePerc = 0.0015
expectedExitSlipagePerc = 0.0015
signalId = "sfp+" + str(bars[0].tstamp)
# SHORT
longSFP = self.entries != 1 and gotHighSwing and bars[1].close + data.buffer < swingHigh
longRej = self.entries != 2 and bars[1].high > hh > bars[1].close + data.buffer and \
highSupreme > minRejLength and bars[1].high - bars[1].close > (bars[1].high - bars[1].low) / 2
# LONG
shortSFP = self.entries != 1 and gotLowSwing and bars[1].close - data.buffer > swingLow
shortRej = self.entries != 2 and bars[1].low < ll < bars[1].close - data.buffer and lowSupreme > minRejLength \
and bars[1].close - bars[1].low > (bars[1].high - bars[1].low) / 2
self.logger.info("---- analyzing: %s: %.1f %.1f %.0f | %s %.0f %i or %i %.0f %.0f | %s %.0f %i or %i %.0f %.0f " %
(str(datetime.fromtimestamp(bars[0].tstamp)), data.buffer, atr, rangeMedian,
gotHighSwing, swingHigh, hhBack, highSupreme, hh ,bars[1].high - bars[1].close,
gotLowSwing, swingLow, llBack, lowSupreme, ll ,bars[1].close - bars[1].low ))
if (longSFP or longRej) and (bars[1].high - bars[1].close) > atr * self.min_wick_fac \
and directionFilter <= 0 and bars[1].high > rangeMedian + atr * self.range_filter_fac:
self.send_signal_message("sfp strat: short entry triggered")
# close existing short pos
if self.close_on_opposite:
for pos in open_positions.values():
if pos.status == PositionStatus.OPEN and TradingBot.split_pos_Id(pos.id)[1] == PositionDirection.LONG:
# execution will trigger close and cancel of other orders
self.order_interface.send_order(
Order(orderId=TradingBot.generate_order_id(pos.id, OrderType.SL),
amount=-pos.amount, stop=None, limit=None))
if self.init_stop_type == 1:
stop = bars[1].high
elif self.init_stop_type == 2:
stop = bars[1].high + (bars[0].high - bars[0].close) * 0.5
else:
stop = max(swingHigh, (bars[1].high + bars[1].close) / 2)
stop = stop + 1 # buffer
entry = bars[0].open
amount = self.calc_pos_size(risk=risk, exitPrice=stop * (1 + expectedExitSlipagePerc),
entry=entry * (1 - expectedEntrySplipagePerc), atr=data.atr)
posId = TradingBot.full_pos_id(signalId, PositionDirection.SHORT)
pos = Position(id=posId, entry=entry, amount=amount, stop=stop,
tstamp=bars[0].tstamp)
open_positions[posId]= pos
self.order_interface.send_order(Order(orderId=TradingBot.generate_order_id(posId, OrderType.ENTRY),
amount=amount, stop=None, limit=None))
self.order_interface.send_order(Order(orderId=TradingBot.generate_order_id(posId, OrderType.SL),
amount=-amount, stop=stop, limit=None))
if self.tp_fac > 0:
ref = entry - stop
if self.tp_use_atr:
ref = math.copysign(data.atr, entry - stop)
tp = entry + ref * self.tp_fac
self.order_interface.send_order(Order(orderId=TradingBot.generate_order_id(posId, OrderType.TP),
amount=-amount, stop=None, limit=tp))
pos.status= PositionStatus.OPEN
if (shortSFP or shortRej) and (bars[1].close - bars[1].low) > atr * self.min_wick_fac \
and directionFilter >= 0 and bars[1].low < rangeMedian - self.range_filter_fac:
self.send_signal_message("sfp strat: long entry triggered")
# close existing short pos
if self.close_on_opposite:
for pos in open_positions.values():
if pos.status == PositionStatus.OPEN and TradingBot.split_pos_Id(pos.id)[1] == PositionDirection.SHORT:
# execution will trigger close and cancel of other orders
self.order_interface.send_order(
Order(orderId=TradingBot.generate_order_id(pos.id, OrderType.SL),
amount=-pos.amount, stop=None, limit=None))
if self.init_stop_type == 1:
stop = bars[1].low
elif self.init_stop_type == 2:
stop = bars[1].low + (bars[0].low - bars[0].close) * 0.5
else:
stop = min(swingLow, (bars[1].low + bars[1].close) / 2)
stop = stop - 1 # buffer
entry = bars[0].open
amount = self.calc_pos_size(risk=risk, exitPrice=stop * (1 - expectedExitSlipagePerc),
entry=entry * (1 + expectedEntrySplipagePerc), atr=data.atr)
posId = TradingBot.full_pos_id(signalId, PositionDirection.LONG)
pos = Position(id=posId, entry=entry, amount=amount, stop=stop,
tstamp=bars[0].tstamp)
pos.status= PositionStatus.TRIGGERED
open_positions[posId]= pos
self.order_interface.send_order(Order(orderId=TradingBot.generate_order_id(posId, OrderType.ENTRY),
amount=amount, stop=None, limit=None))
self.order_interface.send_order(Order(orderId=TradingBot.generate_order_id(posId, OrderType.SL),
amount=-amount, stop=stop, limit=None))
if self.tp_fac > 0:
tp = entry + (entry - stop) * self.tp_fac
self.order_interface.send_order(Order(orderId=TradingBot.generate_order_id(posId, OrderType.TP),
amount=-amount, stop=None, limit=tp))
