def __init__(self,
_fit_period: int = 60,
_fit_begin: int = 252,
_factor: int = 1,
_smooth_period: int = 1,
_use_key: str = 'closeprice',
_idx_key: str = 'time',
_ret_key: typing.Tuple[str] = ('estimate', 'predict')):
super().__init__()
self.fit_count = 0
self.fit_period = _fit_period
self.fit_begin = _fit_begin
self.factor = math.sqrt(_factor)
self.smooth_period = _smooth_period
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct(
[self.idx_key, self.ret_key[0], self.ret_key[1]], self.idx_key)
self.last_price = None
self.rate_buf = []
self.param = None
self.sigma2 = None
def __init__(self,
_period: int,
_use_key: str,
_init_n: int = 20,
_min_n: int = 20,
_max_n: int = 60,
_rate: float = 2.0,
_idx_key: str = 'time'):
super().__init__()
self.use_key = _use_key
self.idx_key = _idx_key
self.keys = [self.idx_key, 'upband', 'midband', 'downband']
self.data = DataStruct(self.keys, self.idx_key)
self.period = _period
self.rate = _rate
self.buf = []
self.prev_std = None
self.dynamic_n = float(_init_n)
self.min_n = _min_n
self.max_n = _max_n
def __init__(
self,
_fit_period: int = 60,
_fit_begin: int = 252,
_use_key: str = 'closeprice',
_idx_key: str = 'time',
_ret_key: typing.Tuple[str] = ('mean', 'std'),
):
super().__init__()
# fitting control
self.fit_count = 0
self.fit_period = _fit_period
self.fit_begin = _fit_begin
self.model = ARMAIGARCHModel(_use_mu=False)
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct(
[self.idx_key, self.ret_key[0], self.ret_key[1]], self.idx_key)
# log return buf
self.last_price = None
self.return_buf = []
# model params
self.phi = None
self.theta = None
self.alpha = None
self.beta = None
self.const = None
self.new_mean = None
self.new_info = None
self.new_var = None
def __init__(
self,
_price_data: DataStruct,
_volatility_data: DataStruct,
_stop_type: int,
_rate: float = 4,
_price_use_key: str = 'closeprice',
_volatility_use_key: str = 'volatility',
_idx_key: str = 'time',
_ret_key: str = 'stopprice',
):
super().__init__()
assert len(_price_data) == 1
assert len(_volatility_data) == 1
self.stop_type = _stop_type
self.rate = _rate
self.price_use_key = _price_use_key
self.volatility_use_key = _volatility_use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct(
[self.idx_key, self.ret_key],
self.idx_key,
)
self._addOne(_price_data, _volatility_data)
def __init__(
self, _ada_period: int=30,
_init_x: float = 0.0, _init_P: float =1.0,
_init_R: float = 0.1 ** 2, _init_Q: float = 0.01 ** 2,
_use_key: str = 'closeprice',
_idx_key: str = 'time', _ret_key: str = 'kalman'
):
super().__init__()
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct(
[self.idx_key, self.ret_key],
self.idx_key
)
self.ada_period = _ada_period
self.value_std = FastSTD(_ada_period, _use_key=self.use_key)
self.x_std = FastSTD(_ada_period, _use_key='x')
self.R = _init_R
self.Q = _init_Q
self.x = _init_x
self.P = _init_P
def __init__(
self,
_data: DataStruct,
_stop_type: int,
_stop_rate: float = 0.05,
_use_key: str = 'closeprice',
_idx_key: str = 'time',
_ret_key: str = 'stopprice',
):
super().__init__()
assert len(_data) == 1
self.stop_type = _stop_type
self.stop_rate = _stop_rate
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
price = _data[self.use_key][0]
if self.stop_type == SignalType.LONG:
stop_price = price * (1 - self.stop_rate)
elif self.stop_type == SignalType.SHORT:
stop_price = price * (1 + self.stop_rate)
else:
raise Exception('unknown type')
time = _data.index()[0]
self.data = DataStruct([self.idx_key, self.ret_key], self.idx_key,
[[time, stop_price]])
def updateData(self) -> typing.Union[None, ReturnMarket, ReturnSettlement]:
if not self.symbol_dict:
self._set_symbol_dict()
self._sub_data()
while True:
# update datetime and tradingday, and check settlement
self.cur_datetime = datetime.utcnow()
cur_tradingday = self.cur_datetime.date().strftime('%Y%m%d')
if self.tradingday != cur_tradingday:
logging.info('New TradingDay: {}'.format(cur_tradingday))
tmp = self.tradingday
self.tradingday = cur_tradingday
return self.addSettlementEvent(tmp)
raw_data = self.data_sub.pop()
# check lts
data_lts = raw_data['lts']
cur_lts = time() * 1000
if data_lts + TIMEOUT < cur_lts: # too old data
continue
symbol = (raw_data['exname'], raw_data['symbol'])
try:
tickers = raw_data['data']['tickers']
for d in tickers:
d['datetime'] = datetime.utcfromtimestamp(d['time'] / 1000)
datastruct = DataStruct(self.column_list,
'datetime',
_dicts=raw_data['data']['tickers'])
return self.addMarketEvent(symbol, datastruct)
except Exception as e:
logging.error('get datastruct error: {}'.format(e))
def __init__(
self,
_price_data: DataStruct,
_atr_data: DataStruct,
_stop_type: int,
_rate: float = 3,
_price_use_key: str = 'closeprice',
_atr_use_key: str = 'atr',
_idx_key: str = 'time',
_ret_key: str = 'stopprice',
):
super().__init__()
assert len(_price_data) == 1
assert len(_atr_data) == 1
self.stop_type = _stop_type
self.rate = _rate
self.price_use_key = _price_use_key
self.atr_use_key = _atr_use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct(
[self.idx_key, self.ret_key],
self.idx_key,
)
self.best_price = _price_data[self.price_use_key][0]
self._addOne(_price_data, _atr_data)
def getSettlementData(self):
tmp = DataStruct(['tradingday', 'fund', 'commission', 'margin'],
'tradingday')
for d in self.settlement_record:
tmp.addDict(d)
return tmp
def __init__(
self,
_fit_period: int = 60,
_fit_begin: int = 252,
_factor: int = 1,
_smooth_period: int = 1,
_use_key: str = 'closeprice',
_idx_key: str = 'time',
_ret_key: str = 'predict',
):
super().__init__()
# fitting control
self.fit_count = 0
self.fit_period = _fit_period
self.fit_begin = _fit_begin
# scale the volatility
self.factor = math.sqrt(_factor)
self.smooth_period = _smooth_period
self.model = IGARCHModel(_use_mu=False)
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct([self.idx_key, self.ret_key], self.idx_key)
# log return buf
self.last_price = None
self.return_buf = []
# model params
self.alpha = None
self.beta = None
self.const = None
self.latent = None
def fetchData(
self, _tradingday: str, _symbol: typing.Tuple[str, str],
_cache=True, _index: str = 'datetime'
) -> typing.Union[None, DataStruct]:
exname, symbol = _symbol
table_name = self.table_key.format(exname, symbol)
key = self.market_key.format(table_name, _tradingday)
if _cache:
try:
return self.cache[key]
except KeyError:
pass
# fetch from database
begin_date = arrow.get(_tradingday, 'YYYYMMDD')
end_date = begin_date.shift(days=1)
con, cur = self._get_psql_con_cur()
cur.execute(
"SELECT * FROM {} WHERE datetime>='{}' AND datetime<'{}' "
"ORDER BY {}".format(
table_name, begin_date, end_date, _index
)
)
data = list(cur.fetchall())
if len(data):
data = DataStruct(self.columns, _index, data)
else:
data = None
if _cache:
self.cache[key] = data
return data
def __init__(
self,
_init_step: float = 0.02,
_max_step: float = 0.2,
_close_key: str = 'closeprice',
_high_key: str = 'highprice',
_low_key: str = 'lowprice',
_idx_key: str = 'time',
_ret_key: str = 'sar',
):
super().__init__()
self.close_key = _close_key
self.high_key = _high_key
self.low_key = _low_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct([self.idx_key, self.ret_key], self.idx_key)
self.init_step = _init_step
self.max_step = _max_step
self.status = self.BEGIN
self.ep = None
self.step = None
self.sar = None
def __init__(
self,
_data: DataStruct,
_stop_type: int,
_stop_rate: float = 0.05,
_use_key: str = 'closeprice',
_idx_key: str = 'time',
_ret_key: str = 'stopprice',
):
super().__init__()
assert len(_data) == 1
self.stop_type = _stop_type
self.stop_rate = _stop_rate
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.best_price = _data.toDict()[self.use_key]
time = _data.index()[0]
self.data = DataStruct([self.idx_key, self.ret_key], self.idx_key,
[[time, self.get_stop_price()]])
def settlement(self, _backtest_key) -> DataStruct:
settlement_list = self.fetchSettlementRecords(_backtest_key)
keys = ['tradingday', 'type', 'fund', 'commission', 'margin']
ret = DataStruct(keys, 'tradingday')
for d in settlement_list:
ret.addDict(d)
return ret
def getSignalData(self):
tmp = DataStruct(
['strategy', 'tradingday', 'datetime', 'symbol', 'strength'],
'datetime')
for d in self.signal_record:
tmp.addDict(d)
return tmp
def __init__(self,
_use_key: str,
_idx_key: str = 'time',
_ret_key: str = 'low'):
super().__init__()
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct([self.idx_key, self.ret_key], self.idx_key)
def fillToBuySell(
self,
_backtest_key: str,
_strategy: str = None) -> typing.Tuple[DataStruct, DataStruct]:
fill_list = self.fetchFillRecords(_backtest_key, _strategy)
keys = [
'type', 'index', 'symbol', 'tradingday', 'datetime', 'quantity',
'action', 'direction', 'price', 'commission', 'strategy'
]
buy_ret = DataStruct(keys, 'datetime')
sell_ret = DataStruct(keys, 'datetime')
for d in fill_list:
if d['direction'] == DirectionType.BUY:
buy_ret.addDict(d)
if d['direction'] == DirectionType.SELL:
sell_ret.addDict(d)
return buy_ret, sell_ret
def signalToLongShort(
self,
_backtest_key: str,
_strategy: str = None) -> typing.Tuple[DataStruct, DataStruct]:
signal_list = self.fetchSignalRecords(_backtest_key, _strategy)
keys = [
'type', 'symbol', 'strategy', 'signal_type', 'tradingday',
'datetime', 'strength'
]
long_ret = DataStruct(keys, 'datetime')
short_ret = DataStruct(keys, 'datetime')
for d in signal_list:
if d['signal_type'] == SignalType.LONG:
long_ret.addDict(d)
if d['signal_type'] == SignalType.SHORT:
short_ret.addDict(d)
return long_ret, short_ret
def getFillData(self):
tmp = DataStruct([
'strategy', 'tradingday', 'datetime', 'symbol', 'index', 'action',
'direction', 'price', 'quantity', 'commission'
], 'datetime')
for d in self.fill_record:
d = copy(d)
d['action'] = ActionType.toStr(d['action'])
d['direction'] = DirectionType.toStr(d['direction'])
tmp.addDict(d)
return tmp
def getOrderData(self):
tmp = DataStruct([
'strategy', 'tradingday', 'datetime', 'symbol', 'index',
'order_type', 'action', 'direction', 'quantity', 'price'
], 'datetime')
for d in self.order_record:
d = copy(d)
d['order_type'] = OrderType.toStr(d['order_type'])
d['action'] = ActionType.toStr(d['action'])
d['direction'] = DirectionType.toStr(d['direction'])
tmp.addDict(d)
return tmp
def __init__(self,
_period: int,
_use_key: str = 'closeprice',
_idx_key: str = 'time',
_ret_key: str = 'momentum'):
super().__init__()
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct([self.idx_key, self.ret_key], self.idx_key)
self.buf = deque(maxlen=_period)
def __init__(
self, _use_key: str, _idx_key: str = 'time',
_ret_key: typing.Sequence[str] = ('open', 'high', 'low', 'close')
):
super().__init__()
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct(
[self.idx_key] + list(self.ret_key),
self.idx_key
)
def updateData(self) -> typing.Union[None, ReturnMarket, ReturnSettlement]:
if not self.symbol_dict:
self._set_symbol_dict()
self._sub_data()
while True:
# update datetime and tradingday, and check settlement
self.cur_datetime = datetime.utcnow()
cur_tradingday = self.cur_datetime.date().strftime('%Y%m%d')
if self.tradingday != cur_tradingday:
logging.info('New TradingDay: {}'.format(cur_tradingday))
tmp = self.tradingday
self.tradingday = cur_tradingday
return self.addSettlementEvent(tmp)
raw_data = self.data_sub.pop()
# check lts
data_lts = raw_data['lts']
cur_lts = time() * 1000
if data_lts + TIMEOUT < cur_lts: # too old data
continue
symbol = (raw_data['exname'], raw_data['symbol'])
tuple_data = clip_depth(raw_data['data'], LEVEL)
try:
last_data = self.last_data_dict[symbol]
if last_data != tuple_data:
return self.addMarketEvent(
symbol,
DataStruct(self.column_list, 'datetime',
[tuple_data + (self.cur_datetime, )]))
else:
continue
except KeyError:
datastruct = DataStruct(self.column_list, 'datetime',
[tuple_data + (self.cur_datetime, )])
return self.addMarketEvent(symbol, datastruct)
finally:
self.last_data_dict[symbol] = tuple_data
def __init__(self,
_skip_period: int = 1,
_use_key: str = 'closeprice',
_idx_key: str = 'time',
_ret_key: str = 'logreturn'):
super().__init__()
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct([self.idx_key, self.ret_key], self.idx_key)
self.skip_period = _skip_period
self.buf = deque(maxlen=self.skip_period)
def __init__(self,
_period: int,
_use_key: str = 'closeprice',
_idx_key: str = 'time',
_ret_key: str = 'kurtosis'):
super().__init__()
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct([self.idx_key, self.ret_key], self.idx_key)
self.period = _period
self.last_price = None
self.buf = deque(maxlen=self.period)
def __init__(
self, _period: int, _use_key: str='closeprice',
_idx_key: str = 'time', _ret_key: str = 'ema'
):
super().__init__()
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct(
[self.idx_key, self.ret_key],
self.idx_key
)
self.period = _period
def fetchDayData(
self, _begin_day: str, _end_day: str,
_symbol: str, _index: str = 'datetime'
) -> DataStruct:
exname, symbol = _symbol
table_name = self.table_key.format(exname, symbol)
con, cur = self._get_psql_con_cur()
cur.execute(
"SELECT * FROM {} WHERE datetime>='{}' AND datetime<'{}' "
"ORDER BY {}".format(
table_name, _begin_day, _end_day, _index
)
)
data = list(cur.fetchall())
return DataStruct(self.columns, _index, data)
def __init__(self,
_period: int = 26,
_use_key: str = 'closeprice',
_rate: float = 2.0,
_idx_key: str = 'time',
_ret_key=('upband', 'midband', 'downband')):
super().__init__()
self.use_key = _use_key
self.idx_key = _idx_key
self.keys = [self.idx_key] + list(_ret_key)
self.data = DataStruct(self.keys, self.idx_key)
self.period = _period
self.rate = _rate
self.buf = deque(maxlen=self.period)
def deal(self, _market_event: MarketEvent):
"""
recv ticker data from market supply,
and split into min, the call do_deal(...)
:param _market_event:
:return:
"""
symbol = _market_event.symbol
data = _market_event.data
for period in self.min_periods:
key = symbol + (period, )
try:
spliter = self.split_dict[key]
except KeyError:
spliter = self.split_dict[key] = SplitIntoMinute(period)
flag = False
for d in data:
flag = flag or spliter.addOne(d)
if flag: # gen new bar
if len(spliter.getBarList()) > 1: # has finished bar
last_bar = spliter.getBarList().pop(0)
last_begin_time = spliter.getBarBeginTimeList().pop(0)
last_end_time = spliter.getBarEndTimeList().pop(0)
price_list = last_bar['price']
volume_list = last_bar['amount']
bar_data = DataStruct([
'open', 'high', 'low', 'close', 'volume', 'begin_time',
'end_time'
], 'begin_time')
bar_data.addDict({
'open': price_list[0],
'high': max(price_list),
'low': min(price_list),
'close': price_list[-1],
'volume': sum(volume_list),
'begin_time': last_begin_time,
'end_time': last_end_time
})
self.do_deal(
MarketEvent(_market_event.market_register_key,
_market_event.strategy,
_market_event.symbol, bar_data), period)
def __init__(self,
_N: int = 30,
_use_key: typing.List[str] = ['highprice', 'lowprice'],
_idx_key: str = 'time',
_ret_key: str = 'rsrs'):
"""
_N: sample length
"""
super().__init__()
self.use_key = _use_key
self.idx_key = _idx_key
self.ret_key = _ret_key
self.data = DataStruct([self.idx_key, self.ret_key], self.idx_key)
self.N = _N
self.high_buf = deque(maxlen=self.N)
self.low_buf = deque(maxlen=self.N)