def get_no_of_shares(self,
capital: float,
pct_risk_per_trade: float,
volume_limit: float,
price: Series,
slippage: int = None,
is_slip_up: bool = True) -> int:
if not AppConsts.PRICE_COL_OPEN in price.index \
or not AppConsts.CUSTOM_COL_ADV in price.index:
return 0
open_price: float = price.loc[AppConsts.PRICE_COL_OPEN]
if slippage:
if is_slip_up:
open_price = NumberUtils.round(open_price + (
open_price * AppConsts.BASIS_POINT * slippage))
else:
open_price = NumberUtils.round(open_price - (
open_price * AppConsts.BASIS_POINT * slippage))
no_of_shares: int = NumberUtils.to_floor(capital * pct_risk_per_trade /
100 / open_price)
adv: float = price.loc[AppConsts.CUSTOM_COL_ADV] if price.loc[
AppConsts.CUSTOM_COL_ADV] > 0 else price.loc[
AppConsts.PRICE_COL_VOLUME]
max_volume: float = NumberUtils.to_int(adv * volume_limit / 100)
if no_of_shares > max_volume:
LogUtils.warning(
'Capping max_volume adv={0}, no_of_shares={1}, max_volume={2}'.
format(adv, no_of_shares, max_volume))
no_of_shares = max_volume
return no_of_shares
def set_readonly_props(self) -> None:
if not self._transactions:
return
self._start_capital = self._capital.get(
ModelUtils.get_first_key(self._capital))
self._end_capital = self._capital.get(
ModelUtils.get_last_key(self._capital))
self._hold_length_days_stats = StatUtils.get_descriptive_stats(
[t.hold_length_days for t in self._transactions])
self._change_in_capital_stats = StatUtils.get_descriptive_stats(
[t.change_in_capital for t in self._transactions])
self._has_profit_stats = StatUtils.get_descriptive_stats(
[NumberUtils.to_int(t.has_profit) for t in self._transactions])
self._pct_return = NumberUtils.get_change(self._end_capital,
self._start_capital)
self._best_transactions = [
t for t in sorted(self._transactions,
key=lambda x: x.change_in_capital,
reverse=True) if t.has_profit
][:20]
self._worst_transactions = [
t for t in sorted(self._transactions,
key=lambda x: x.change_in_capital)
if not t.has_profit
][:20]
symbol_grouped: Dict = {}
for t in self._transactions:
if not t.symbol_master.symbol in symbol_grouped:
symbol_grouped[t.symbol_master.symbol]: Dict = {
'symbol_master': t.symbol_master,
'change_in_capital': 0,
'no_of_transactions': 0
}
symbol_grouped[t.symbol_master.
symbol]['change_in_capital'] += t.change_in_capital
symbol_grouped[t.symbol_master.symbol]['no_of_transactions'] += 1
symbol_grouped_list: List[BackTestResultItemPerSymbol] = []
for k, v in symbol_grouped.items():
item: BackTestResultItemPerSymbol = BackTestResultItemPerSymbol()
item.symbol_master = symbol_grouped[k]['symbol_master']
item.change_in_capital = NumberUtils.round(
symbol_grouped[k]['change_in_capital'])
item.no_of_transactions = symbol_grouped[k]['no_of_transactions']
symbol_grouped_list.append(item)
self._best_symbols = [
i for i in sorted(symbol_grouped_list,
key=lambda x: x.change_in_capital,
reverse=True) if i.change_in_capital > 0
][:20]
self._worst_symbols = [
i for i in sorted(symbol_grouped_list,
key=lambda x: x.change_in_capital)
if i.change_in_capital < 0
][:20]
def set_readonly_props(self) -> None:
if not hasattr(self, 'start_date') \
or not hasattr(self, 'end_date') \
or not hasattr(self, 'start_price') \
or not hasattr(self, 'end_price') \
or not hasattr(self, 'no_of_shares') \
or not hasattr(self, 'action'):
return
delta: timedelta = DateUtils.get_diff(self._end_date, self._start_date)
if self._action == AppConsts.ACTION_BUY:
self._net_change_in_price = NumberUtils.round(self._end_price -
self._start_price)
elif self._action == AppConsts.ACTION_SELL:
self._net_change_in_price = NumberUtils.round(self._start_price -
self._end_price)
self._year = self._end_date.year
self._quarter = DateUtils.get_quarter(self._end_date.month)
self._month = self._end_date.month
self._hold_length_days = delta.days if delta else 0
self._change_in_capital = NumberUtils.round(self._net_change_in_price *
self._no_of_shares)
self._has_profit = (self._change_in_capital > 0)
def __calc_benchmark_capital(self, req: BackTestRunRequest,
start_price: float, end_price: float,
no_of_shares: int) -> float:
capital: float = req.start_capital - (start_price * no_of_shares)
return NumberUtils.round(capital + (end_price * no_of_shares))
def run(self, req: BackTestRunRequest) -> BackTestRunResponse:
if not req or not req.is_valid_model():
raise BadRequestException()
response: BackTestRunResponse = BackTestRunResponse(req)
# Init Symbols
symbols: List[SymbolMaster] = self.__get_symbols__(req)
# Init Prices
prices: DataFrame = self.__get_prices__(req, symbols)
# Do Base Preparation
prices[AppConsts.CUSTOM_COL_PV] = prices[
AppConsts.PRICE_COL_CLOSE] * prices[AppConsts.PRICE_COL_VOLUME]
for s in symbols:
prices = self.__calc_service.append_sma(
prices=prices,
index=[s.id],
sma_period=AppConsts.ADV_PERIOD_DFLT,
sma_column_name=AppConsts.CUSTOM_COL_ADV,
target_column=AppConsts.PRICE_COL_VOLUME)
prices = self.__calc_service.append_sma(
prices=prices,
index=[s.id],
sma_period=AppConsts.ADPV_PERIOD_DFLT,
sma_column_name=AppConsts.CUSTOM_COL_ADPV,
target_column=AppConsts.CUSTOM_COL_PV)
LogUtils.debug('Prices shape after base preparation={0}'.format(
prices.shape))
# region Init Service
strategy_service: Any = self.__stock_service.get_strategy_service(
req.strategy_type, req.strategy_request, symbols, prices)
if not strategy_service or not strategy_service._is_valid_request():
raise BadRequestException()
strategy_service._do_preparations()
LogUtils.debug('Prices shape after strategy preparation={0}'.format(
prices.shape))
# endregion
LogUtils.debug(prices.info())
# region Init Dates
start_date: date = DateUtils.add_business_days(req.date_from_obj, -1)
start_date = DateUtils.add_business_days(start_date, 1)
start_date_str: str = DateUtils.to_string(start_date)
end_date: date = DateUtils.add_business_days(req.date_to_obj, -1)
dates: DataFrame = self.__stock_service.get_dates(
prices, start_date, end_date)
LogUtils.debug(
'Dates actual_start={0}, actual_end={1}, shape={2}'.format(
start_date, end_date, dates.shape))
# endregion
# region Loop Dates
strategy_item: BackTestResultItem = next(
b for b in response.back_test_result_items
if b.target == req.strategy_type)
strategy_item.capital[start_date_str] = req.start_capital
strategy_item.capital_available[start_date_str] = req.start_capital
portfolio: Dict = {}
for i, date_row in dates.iterrows():
current_date = date_row[AppConsts.PRICE_COL_DATE]
current_date_str: str = DateUtils.to_string(current_date)
next_date = date_row[AppConsts.CUSTOM_COL_NEXT_DATE]
next_date_str = DateUtils.to_string(next_date)
next_next_date = date_row[AppConsts.CUSTOM_COL_NEXT_NEXT_DATE]
shuffle(symbols)
for symbol in symbols:
has_price: bool = (symbol.id, current_date) in prices.index
if not has_price:
continue
price: Series = prices.loc[symbol.id, current_date]
if symbol.instrument == AppConsts.INSTRUMENT_ETF:
# region Benchmark
b_result_item: BackTestResultItem = next(
b for b in response.back_test_result_items
if b.target == symbol.symbol)
if not b_result_item:
continue
if not b_result_item.transactions:
no_of_shares: int = self.__stock_service.get_no_of_shares(
req.start_capital, req.pct_risk_per_trade,
req.volume_limit, price, req.slippage)
if no_of_shares == 0:
LogUtils.warning('0 shares for ETF={0}'.format(
symbol.symbol))
continue
b_transaction: Transaction = Transaction()
b_transaction.symbol_master = symbol
b_transaction.action = AppConsts.ACTION_BUY
b_transaction.start_date = current_date
b_transaction.start_price = price.loc[
AppConsts.PRICE_COL_OPEN]
b_transaction.no_of_shares = no_of_shares
b_result_item.transactions.append(b_transaction)
b_result_item.capital[
current_date_str] = req.start_capital
else:
b_transaction: Transaction = b_result_item.transactions[
0]
b_transaction.end_date = current_date
b_transaction.end_price = price.loc[
AppConsts.PRICE_COL_CLOSE]
b_transaction.set_readonly_props()
b_result_item.capital[
current_date_str] = self.__calc_benchmark_capital(
req, b_transaction.start_price,
b_transaction.end_price,
b_transaction.no_of_shares)
b_result_item.ttl_no_days += 1
# endregion
else:
# region Strategy
strategy_service._do_calculations(symbol.id, current_date)
action: str = strategy_service._get_action()
is_in_position: bool = symbol.id in portfolio
if not is_in_position:
if len(portfolio
) == req.portfolio_max: # todo: prioritize?
continue
if current_date == end_date or next_date >= end_date:
continue
has_next_price: bool = (symbol.id,
next_date) in prices.index
has_next_next_price: bool = (
symbol.id, next_next_date) in prices.index
if not has_next_price or not has_next_next_price:
continue
adv: float = price.loc[
AppConsts.CUSTOM_COL_ADV] if price.loc[
AppConsts.CUSTOM_COL_ADV] > 0 else price.loc[
AppConsts.PRICE_COL_VOLUME]
if adv < req.adv_min:
continue
adpv: float = price.loc[
AppConsts.CUSTOM_COL_ADPV] if price.loc[
AppConsts.CUSTOM_COL_ADPV] > 0 else price.loc[
AppConsts.CUSTOM_COL_PV]
if adpv < req.adpv_min:
continue
next_price: Series = prices.loc[symbol.id, next_date]
has_entry_conditions: bool = strategy_service._has_entry_conditions(
symbol.id, current_date)
if has_entry_conditions:
no_of_shares: int = self.__stock_service.get_no_of_shares(
strategy_item.
capital_available[current_date_str],
req.pct_risk_per_trade, req.volume_limit,
next_price, req.slippage,
action == AppConsts.ACTION_BUY)
if no_of_shares == 0:
continue
trans: Transaction = Transaction()
trans.symbol_master = symbol
trans.action = action
trans.start_date = next_date
trans.start_price = next_price.loc[
AppConsts.PRICE_COL_OPEN]
trans.no_of_shares = no_of_shares
trans_amount: float = NumberUtils.round(
trans.start_price * no_of_shares)
strategy_item.capital_available[
current_date_str] -= trans_amount
# Add to portfolio
portfolio[symbol.id] = trans
elif is_in_position:
has_exit_conditions: bool = strategy_service._has_exit_conditions(
symbol.id, current_date)
has_next_next_price: bool = (
symbol.id, next_next_date) in prices.index
if next_date == end_date or not has_next_next_price or has_exit_conditions:
next_price: Series = prices.loc[symbol.id,
next_date]
next_open_price: float = next_price.loc[
AppConsts.PRICE_COL_OPEN]
slippage_price: float = 0
if action == AppConsts.ACTION_BUY:
slippage_price: float = NumberUtils.round(
next_open_price -
(next_open_price * AppConsts.BASIS_POINT *
req.slippage))
else:
slippage_price: float = NumberUtils.round(
next_open_price +
(next_open_price * AppConsts.BASIS_POINT *
req.slippage))
trans: Transaction = portfolio.get(symbol.id)
trans.end_date = next_date
trans.end_price = slippage_price
trans.set_readonly_props()
strategy_item.transactions.append(trans)
if action == AppConsts.ACTION_BUY:
trans_amount = NumberUtils.round(
trans.end_price * trans.no_of_shares)
strategy_item.capital_available[
current_date_str] += trans_amount
else:
init_trans_amount = NumberUtils.round(
trans.start_price * trans.no_of_shares)
strategy_item.capital_available[
current_date_str] += init_trans_amount
strategy_item.capital_available[
current_date_str] += trans.change_in_capital
# Remove from portfolio
portfolio.pop(symbol.id, None)
# endregion
# capital = capital available + capital in portfolio
capital: float = strategy_item.capital_available[current_date_str]
for key, val in portfolio.items():
price: Series = prices.loc[key, current_date]
capital += price.loc[
AppConsts.PRICE_COL_CLOSE] * val.no_of_shares
strategy_item.capital[current_date_str] = NumberUtils.round(
capital)
strategy_item.ttl_no_days += 1
strategy_item.capital[next_date_str] = strategy_item.capital[
current_date_str]
strategy_item.capital_available[
next_date_str] = strategy_item.capital_available[
current_date_str]
# endregion
for result_item in response.back_test_result_items:
result_item.set_readonly_props()
return response
