class Mike_Dc_Strategy(CtaTemplate):
""""""
author = "yunya"
exchange : Exchange = ""
mike_window = 1
mike_length = 30
dc_length = 10
kk_length = 20
kk_dev = 2.0
sl_trade = 2
fixed_size = 1
ask = 0
bid = 0
ema_mid = 0
ema_hh = 0
ema_ll = 0
ema_wr = 0 #初级压力线
ema_mr = 0 #中级压力线
ema_sr = 0 #高级压力线
ema_ws = 0 #初级支撑线
ema_ms = 0 #中级支撑线
ema_ss = 0 #高级支撑线
dc_up = 0
dc_down = 0
kk_up = 0
kk_down = 0
atr_value = 0
long_stop = 0
short_stop = 0
long_stop_trade = 0
short_stop_trade = 0
long_enrty = 0
short_enrty = 0
ema_entry_crossover = 0
boll_entry_crossover = 0
boll_width = 0
parameters = [
"exchange",
"mike_window",
"mike_length",
"dc_length",
"kk_length",
"kk_dev",
"sl_trade",
"fixed_size",
]
variables = [
"long_stop",
"short_stop",
"ema_entry_crossover",
"boll_entry_crossover",
"boll_width",
"ema_mid",
"ema_hh",
"ema_ll",
"ema_wr",
"ema_mr",
"ema_sr",
"ema_ws",
"ema_ms",
"ema_ss",
]
def __init__(self, cta_engine, strategy_nam_xhoure, vt_symbol, setting):
""""""
super().__init__(cta_engine, strategy_nam_xhoure, vt_symbol, setting)
self.bg_xhour = BarGenerator(
on_bar=self.on_bar,
window=self.mike_window,
on_window_bar=self.on_hour_bar,
interval=Interval.HOUR
)
self.am_xhour = ArrayManager(max(self.dc_length ,self.kk_length) + 10)
def on_init(self):
"""
Callback when strategy is inited.
"""
self.write_log("策略初始化")
self.exchange_load_bar(self.exchange)
def on_start(self):
"""
Callback when strategy is started.
"""
self.write_log("策略启动")
def on_stop(self):
"""
Callback when strategy is stopped.
"""
self.write_log("策略停止")
def on_tick(self, tick: TickData):
"""
Callback of new tick data update.
"""
self.bg_xhour.update_tick(tick)
self.ask = tick.ask_price_1 # 卖一价
self.bid = tick.bid_price_1 # 买一价
def on_bar(self, bar: BarData):
"""
Callback of new bar data update.
"""
self.bg_xhour.update_bar(bar)
def on_hour_bar(self, bar: BarData):
"""
计算 mike 指标线
:param_xhour bar:
:return:
"""
self.am_xhour.update_bar(bar)
if not self.am_xhour.inited:
return
# 计算mike压力支撑线
ema_array = (self.am_xhour.close[:-1] + self.am_xhour.high[:-1] + self.am_xhour.low[:-1]) / 3
self.ema_mid = ema_array[-1]
self.ema_hh = self.am_xhour.high[-self.mike_length:-1].max()
self.ema_ll = self.am_xhour.low[-self.mike_length:-1].min()
self.ema_wr = self.ema_mid + (self.ema_mid - self.ema_ll)
self.ema_mr = self.ema_mid + (self.ema_hh - self.ema_ll)
self.ema_sr = 2 * self.ema_hh - self.ema_ll
self.ema_ws = self.ema_mid - (self.ema_hh - self.ema_mid)
self.ema_ms = self.ema_mid - (self.ema_hh - self.ema_ll)
self.ema_ss = 2 * self.ema_ll - self.ema_hh
if (self.am_xhour.close[-1] > self.ema_sr) or (self.ema_ms < self.am_xhour.close[-1] < self.ema_ws):
self.ema_entry_crossover = 1
elif (self.am_xhour.close[-1] < self.ema_ss) or (self.ema_mr > self.am_xhour.close[-1] > self.ema_wr):
self.ema_entry_crossover = -1
self.kk_up,self.kk_down = self.am_xhour.keltner(self.kk_length,self.kk_dev)
self.dc_up,self.dc_down = self.am_xhour.donchian(self.dc_length)
if self.pos == 0:
self.atr_value = self.am_xhour.atr(30)
if self.ema_entry_crossover > 0 :
self.buy(self.kk_up, self.fixed_size,True)
print(self.kk_up)
elif self.ema_entry_crossover < 0 :
self.short(self.kk_down, self.fixed_size,True)
elif self.pos > 0:
self.long_stop = max(self.dc_down,self.long_stop_trade)
self.sell(self.long_stop, abs(self.pos), True)
elif self.pos < 0:
self.short_stop = min(self.dc_up,self.short_stop_trade)
self.cover(self.short_stop, abs(self.pos), True)
self.sync_data()
self.put_event()
def on_order(self, order: OrderData):
"""
Callback of new order data update.
"""
pass
# self.write_log(f"on_order: status:{order.status}, orderid: {order.vt_orderid}, offset:{order.offset}, price:{order.price}, volume:{order.volume}, traded: {order.traded}")
# self.put_event()
def on_trade(self, trade: TradeData):
"""
Callback of new trade data update.
"""
# if trade.direction == Direction.LONG:
# self.long_enrty = trade.price
# self.long_stop_trade = self.long_enrty - 2 * self.atr_value
#
# else:
# self.short_enrty = trade.price
# self.short_stop_trade = self.short_enrty + 2 * self.atr_value
self.put_event()
def on_stop_order(self, stop_order: StopOrder):
"""
Callback of stop order update.
"""
pass
def exchange_load_bar(self,exchange:Exchange):
"""
如果是火币，ok 交易所，就从数据库获取初始化数据
"""
if exchange == Exchange.OKEX or exchange == Exchange.HUOBI:
self.load_bar(days=10,use_database=True)
else:
self.load_bar(10)
class TurtleSignal(object):
""""""
# ----------------------------------------------------------------------
def __init__(self, entryWindow, exitWindow, entryDev, exitDev, rsiWindow,
rsiSignal):
"""Constructor"""
self.entryWindow = entryWindow
self.exitWindow = exitWindow
self.entryDev = entryDev
self.exitDev = exitDev
self.rsiWindow = rsiWindow
self.rsiSignal = rsiSignal
self.am = ArrayManager(60)
self.atrVolatility = 0
self.entryUp = 0
self.entryDown = 0
self.exitUp = 0
self.exitDown = 0
self.rsiValue = 0
self.unit = 0
self.result = None
self.lastResult = None
# ----------------------------------------------------------------------
def onBar(self, bar):
""""""
self.am.update_bar(bar)
if not self.am.inited:
return
self.generateSignal(bar)
self.calculateIndicator()
# ----------------------------------------------------------------------
def calculateIndicator(self):
""""""
keltnerEntryUp, keltnerEntryDown = self.am.keltner(
self.entryWindow, self.entryDev)
keltnerExitUp, keltnerExitDown = self.am.keltner(
self.exitWindow, self.exitDev)
donchianEntryUp, donchianEntryDown = self.am.donchian(self.entryWindow)
donchianExitUp, donchianExitDown = self.am.donchian(self.exitWindow)
self.entryUp = max(donchianEntryUp, keltnerEntryUp)
self.entryDown = min(donchianEntryDown, keltnerEntryDown)
self.exitUp = min(keltnerExitUp, donchianExitUp)
self.exitDown = max(keltnerExitDown, donchianExitDown)
self.rsiValue = self.am.rsi(self.rsiWindow)
# ----------------------------------------------------------------------
def generateSignal(self, bar):
""""""
# 平仓
if self.unit > 0:
if bar.low_price <= self.exitDown:
self.close(self.exitDown)
if self.unit < 0:
if bar.high_price >= self.exitUp:
self.close(self.exitUp)
# 开仓
else:
if self.rsiValue >= (50 + self.rsiSignal):
if bar.high_price >= self.entryUp:
self.open(self.entryUp, 1)
elif self.rsiValue <= (50 - self.rsiSignal):
if bar.low_price <= self.entryDown:
self.open(self.entryDown, -1)
# ----------------------------------------------------------------------
def open(self, price, change):
""""""
self.unit += change
if not self.result:
self.result = TurtleResult()
self.result.open(price, change)
# ----------------------------------------------------------------------
def close(self, price):
""""""
self.unit = 0
self.result.close(price)
self.lastResult = self.result
self.result = None
# ----------------------------------------------------------------------
def getLastPnl(self):
""""""
if not self.lastResult:
return 0
return self.lastResult.pnl
class DudlThrustKkStrategy(CtaTemplate):
""""""
author = "yunyu"
xminute_window = 1
rolling_period = 70
upper_open = 0.2
lower_open = 0.2
cci_window = 30
keltner_window = 24
keltner_dev = 1
fixed_size = 1
cci_value = 0
exit_kk_up = 0
exit_kk_down = 0
dualthrust_up = 0
dualthrust_down = 0
ask = 0
bid = 0
parameters = [
"xminute_window",
"rolling_period",
"upper_open",
"lower_open",
"cci_window",
"keltner_window",
"keltner_dev",
"fixed_size",
]
variables = [
"dualthrust_up",
"dualthrust_down",
"cci_value",
"exit_kk_up",
"exit_kk_down",
]
def __init__(self, cta_engine, strategy_name, vt_symbol, setting):
""""""
super().__init__(cta_engine, strategy_name, vt_symbol, setting)
self.bg = NewBarGenerator(on_bar=self.on_bar,
window=self.xminute_window,
on_window_bar=self.on_min_bar,
interval=Interval.MINUTE)
self.am = ArrayManager()
def on_init(self):
"""
Callback when strategy is inited.
"""
self.write_log("策略初始化")
self.load_bar(10)
def on_start(self):
"""
Callback when strategy is started.
"""
self.write_log("策略启动")
def on_stop(self):
"""
Callback when strategy is stopped.
"""
self.write_log("策略停止")
def on_tick(self, tick: TickData):
"""
Callback of new tick data update.
"""
self.bg.update_tick(tick)
self.ask = tick.ask_price_1 # 卖一价
self.bid = tick.bid_price_1 # 买一价
def on_bar(self, bar: BarData):
"""
Callback of new bar data update.
"""
self.bg.update_bar(bar)
def on_min_bar(self, bar: BarData):
"""
Callback of new bar data update.
"""
self.am.update_bar(bar)
self.cancel_all()
if not self.am.inited:
return
self.dualthrust_up, self.dualthrust_down = self.dualthrust(
self.am.high, self.am.low, self.am.close, self.am.open,
self.rolling_period, self.upper_open, self.lower_open)
self.cci_value = self.am.cci(self.cci_window)
print(self.cci_value)
self.keltner_up, self.keltner_down = self.am.keltner(
self.keltner_window, self.keltner_dev)
if self.pos == 0:
if self.cci_value > 0:
self.buy(self.dualthrust_up, self.fixed_size, True)
elif self.cci_value < 0:
self.short(self.dualthrust_down, self.fixed_size, True)
elif self.pos > 0:
self.sell(self.exit_kk_down, self.fixed_size, True)
elif self.pos < 0:
self.cover(self.exit_kk_up, self.fixed_size, True)
self.put_event()
self.sync_data()
self.put_event()
def on_order(self, order: OrderData):
"""
Callback of new order data update.
"""
pass
def on_trade(self, trade: TradeData):
"""
Callback of new trade data update.
"""
self.put_event()
def on_stop_order(self, stop_order: StopOrder):
"""
Callback of stop order update.
"""
pass
# self.put_event()
def market_order(self):
""""""
pass
# self.buy(self.last_tick.limit_up, 1)
# self.write_log("执行市价单测试")
def limit_order(self):
""""""
pass
# self.buy(self.last_tick.limit_down, 1)
# self.write_log("执行限价单测试")
def stop_order(self):
""""""
pass
# self.buy(self.last_tick.ask_price_1, 1, True)
# self.write_log("执行停止单测试")
def dualthrust(self, high, low, close, open, n, k1, k2):
"""
:param high:
:param low:
:param close:
:return:
"""
#计算N日最高价的最高价，收盘价的最高价、最低价，最低价的最低价
hh = high[-n:].max()
lc = close[-n:].min()
hc = close[-n:].max()
ll = low[-n:].min()
#计算range,上下轨的距离前一根K线开盘价的距离
range = max(hh - lc, hc - ll)
up = open[-2] + k1 * range
down = open[-2] - k2 * range
return up, down
class KeltnerTrendStrategy(CtaTemplate):
""""""
author = "用Python的交易员"
kk_window = 5
kk_dev = 1.3
aroon_window = 2
aroon_signal = 50
trailing_percent = 1.2
fixed_size = 1
kk_up = 0
kk_down = 0
aroon_up = 0
aroon_down = 0
intra_trade_high = 0
intra_trade_low = 0
long_vt_orderids = []
short_vt_orderids = []
vt_orderids = []
parameters = ["kk_window", "kk_dev", "aroon_window", "aroon_signal", "trailing_percent", "fixed_size"]
variables = ["kk_up", "kk_down", "aroon_up", "aroon_down"]
def __init__(self, cta_engine, strategy_name, vt_symbol, setting):
""""""
super().__init__(cta_engine, strategy_name, vt_symbol, setting)
self.bg = BarGenerator(self.on_bar, 5, self.on_5min_bar)
self.am = ArrayManager()
self.am5 = ArrayManager()
def on_init(self):
"""
Callback when strategy is inited.
"""
self.write_log("策略初始化")
self.load_bar(10)
def on_start(self):
"""
Callback when strategy is started.
"""
self.write_log("策略启动")
def on_stop(self):
"""
Callback when strategy is stopped.
"""
self.write_log("策略停止")
def on_tick(self, tick: TickData):
"""
Callback of new tick data update.
"""
self.bg.update_tick(tick)
def on_bar(self, bar: BarData):
"""
Callback of new bar data update.
"""
self.bg.update_bar(bar)
self.am.update_bar(bar)
if not self.am.inited:
return
self.aroon_up, self.aroon_down = self.am.aroon(self.aroon_window)
def on_5min_bar(self, bar: BarData):
""""""
self.cancel_all()
self.am5.update_bar(bar)
if not self.am5.inited:
return
self.kk_up, self.kk_down = self.am5.keltner(self.kk_window, self.kk_dev)
if self.pos == 0:
self.intra_trade_high = bar.high_price
self.intra_trade_low = bar.low_price
if self.aroon_up >= self.aroon_signal:
self.buy(self.kk_up, self.fixed_size, True)
elif self.aroon_down >= self.aroon_signal:
self.short(self.kk_down, self.fixed_size, True)
elif self.pos > 0:
self.intra_trade_high = max(self.intra_trade_high, bar.high_price)
self.intra_trade_low = bar.low_price
long_stop = self.intra_trade_high * (1 - self.trailing_percent / 100)
self.sell(long_stop, abs(self.pos), True)
elif self.pos < 0:
self.intra_trade_high = bar.high_price
self.intra_trade_low = min(self.intra_trade_low, bar.low_price)
short_stop = self.intra_trade_low * (1 + self.trailing_percent / 100)
self.cover(short_stop, abs(self.pos), True)
self.put_event()
def on_order(self, order: OrderData):
"""
Callback of new order data update.
"""
pass
def on_trade(self, trade: TradeData):
"""
Callback of new trade data update.
"""
self.put_event()
def on_stop_order(self, stop_order: StopOrder):
"""
Callback of stop order update.
"""
pass
