dynamic.py

"""

The starter system has the following features:

- single market
- binary forecast from simple MAV
- exit from trailing stop loss
- fixed positions once in trade

"""
import matplotlib
matplotlib.use("TkAgg")

from systems.defaults import system_defaults
from syscore.genutils import sign
from systems.provided.futures_chapter15.basesystem import *
from sysdata.configdata import Config
from systems.forecasting import TradingRule
from systems.positionsizing import PositionSizing
from systems.system_cache import  diagnostic, output


from copy import copy
import numpy as np
import pandas as pd
from random import getrandbits
import matplotlib.pylab as plt



def simple_mav(price, short=16, long=64, forecast_fixed=10):
    """
    Simple moving average crossover

    :param price:
    :param short: days for short
    :param long: days for short
    :return: binary time series
    """

    short_mav = price.rolling(short, min_periods=1).mean()
    long_mav = price.rolling(long, min_periods=1).mean()

    signal = short_mav - long_mav

    binary = signal.apply(sign)
    binary_position = forecast_fixed * binary

    return binary_position

class simpleSysystemPosition(object):
    def __init__(self,  dynamic_vol=False, dynamic_SL = False):
        self.current_position = 0.0
        self.previous_position = 0.0
        self.dynamic_vol = dynamic_vol
        self.dynamic_SL = dynamic_SL

    def no_position_check_for_trade(self, original_position_now, current_price, current_vol):
        assert self.no_current_position
        if np.isnan(original_position_now):
            # no signal
            return 0.0

        if original_position_now ==0.0:
            return 0.0

        # potentially going long / short
        # check last position to avoid whipsaw
        if self.previous_position != 0.0:
             # same way round avoid whipsaw
            if sign(
                original_position_now) == sign(self.previous_position):
                return 0.0

        self.initialise_trade(original_position_now, current_price, current_vol)
        return original_position_now

    @property
    def no_current_position(self):
        return self.current_position==0.0

    def initialise_trade(self, original_position_now, current_price, current_vol):
        # okay to do this - we don't want to enter a new position unless sign changed
        # we set the position at the sized position at moment of
        # inception
        self.current_position = original_position_now
        self.price_list_since_position_held = [current_price]
        self.initial_vol = current_vol
        self.initial_position = original_position_now

        return original_position_now

    def position_on_check_for_close(self, current_price, current_vol):
        assert not self.no_current_position

        # already holding a position
        # calculate HWM
        self.update_price_series(current_price)
        new_position = self.vol_adjusted_position(current_vol)

        time_to_close_trade =self.check_if_hit_stoploss(current_vol)

        if time_to_close_trade:
            self.close_trade()

        return new_position

    def update_price_series(self, current_price):
        price_list_since_position_held = self.price_list_since_position_held
        price_list_since_position_held.append(current_price)

    def vol_adjusted_position(self, current_vol):
        initial_position = self.initial_position
        if self.dynamic_vol:
            vol_adjusted_position = (self.initial_vol / current_vol) * initial_position
            return vol_adjusted_position
        else:
            return initial_position

    def check_if_hit_stoploss(self, current_vol):
        stoploss_gap = self.stoploss_gap(current_vol)

        sign_position = sign(self.current_position)
        if sign_position == 1:
            # long
            time_to_close_trade = self.check_if_long_stop_hit(stoploss_gap)
        else:
            # short
            time_to_close_trade = self.check_if_short_stop_hit(stoploss_gap)

        return time_to_close_trade

    def stoploss_gap(self, current_vol):
        xfactor = self.Xfactor

        if self.dynamic_vol:
            vol = current_vol
        else:
            vol = self.initial_vol

        stoploss_gap = vol * xfactor

        return stoploss_gap

    @property
    def Xfactor(self):
        if self.dynamic_SL:
            return self.dynamic_xfactor()
        else:
            return fixed_xfactor()

    def dynamic_xfactor(self):
        pandl_vol_units = self.vol_adjusted_profit_since_trade_points()
        return dynamic_xfactor(pandl_vol_units)

    def vol_adjusted_profit_since_trade_points(self):
        if self.no_current_position:
            return 0.0

        initial_vol = self.initial_vol
        profit_price_units = self.profit_since_trade_points()

        return profit_price_units / initial_vol

    def profit_since_trade_points(self):
        assert not self.no_current_position
        current_position = self.current_position
        if current_position>0:
            return self.current_price - self.initial_price
        else:
            return self.initial_price - self.current_price

    @property
    def current_price(self):
        price_list_since_position_held = self.price_list_since_position_held
        current_price = price_list_since_position_held[-1]

        return current_price

    @property
    def initial_price(self):
        price_list_since_position_held = self.price_list_since_position_held
        initial_price = price_list_since_position_held[0]

        return initial_price

    def check_if_long_stop_hit(self, stoploss_gap):
        threshold = self.hwm - stoploss_gap
        time_to_close_trade = self.current_price < threshold

        return time_to_close_trade

    def check_if_short_stop_hit(self, stoploss_gap):
        threshold = self.hwm + stoploss_gap
        time_to_close_trade = self.current_price > threshold

        return time_to_close_trade

    @property
    def hwm(self):
        current_position = self.current_position
        if current_position > 0:
            return self.hwm_when_long()
        else:
            return self.hwm_when_short()

    def hwm_when_long(self):
        price_list_since_position_held = self.price_list_since_position_held
        hwm = np.nanmax(price_list_since_position_held)

        return hwm

    def hwm_when_short(self):
        price_list_since_position_held = self.price_list_since_position_held
        hwm = np.nanmin(price_list_since_position_held)

        return hwm

    def close_trade(self):
        self.previous_position = copy(self.current_position)
        self.current_position = 0.0
        self.price_list_since_position_held = []
        del(self.initial_vol)
        del(self.initial_position)

def fixed_xfactor():
    return 8.0

def dynamic_xfactor(pandl_vol_units):
    MINIMUM_XFACTOR = 2.0
    MAXIMUM_XFACTOR = 8.0
    PANDL_UPPER_CUTOFF = 8.0
    PANDL_LOWER_CUTOFF = 0.0
    if pandl_vol_units<=PANDL_LOWER_CUTOFF:
        return MINIMUM_XFACTOR
    elif pandl_vol_units>PANDL_UPPER_CUTOFF:
        return MAXIMUM_XFACTOR
    else:
        return MINIMUM_XFACTOR + (pandl_vol_units)*(MAXIMUM_XFACTOR - MINIMUM_XFACTOR)/(PANDL_UPPER_CUTOFF - PANDL_LOWER_CUTOFF)


def stoploss(price, vol, raw_position, dynamic_vol=False, dynamic_SL = False):
    """
    Apply trailing stoploss

    :param price:
    :param vol: eg system.rawdata.daily_returns_volatility("SP500")
    :param raw_position: Raw position series, without stoploss or entry / exit logic
    :return: New position series
    """
    assert all(vol.index == price.index)
    assert all(price.index == raw_position.index)

    # assume all lined up
    simple_system_position = simpleSysystemPosition(
                                                    dynamic_vol=dynamic_vol,
                                                    dynamic_SL=dynamic_SL)
    new_position_list = []

    for iday in range(len(price)):
        current_price = price[iday]
        current_vol = vol[iday]

        if simple_system_position.no_current_position:
            # no position, check for signal
            original_position_now = raw_position[iday]
            new_position = simple_system_position.no_position_check_for_trade(original_position_now,
                                                                              current_price, current_vol)
        else:
            new_position = simple_system_position.position_on_check_for_close(
                                                                              current_price, current_vol)

        new_position_list.append(new_position)

    new_position_df = pd.Series(new_position_list, raw_position.index)

    return new_position_df


class PositionSizeWithStopLoss(PositionSizing):
    @diagnostic()
    def get_subsystem_position_preliminary(self, instrument_code):
        """
        Get scaled position (assuming for now we trade our entire capital for one instrument)

        """
        self.log.msg(
            "Calculating subsystem position for %s" % instrument_code,
            instrument_code=instrument_code,
        )
        """
        We don't allow this to be changed in config
        """
        avg_abs_forecast = system_defaults["average_absolute_forecast"]

        vol_scalar = self.get_volatility_scalar(instrument_code)

        # forecast is binary + or - avg-abs-forecast
        forecast = self.get_combined_forecast(instrument_code)

        vol_scalar = vol_scalar.reindex(forecast.index).ffill()

        # put on a position according to vol and sign of forecast; this will only take effect on a new trade
        subsystem_position = vol_scalar * forecast / avg_abs_forecast

        return subsystem_position

    @output()
    def get_subsystem_position(self, instrument_code):
        """
        Get scaled position (assuming for now we trade our entire capital for one instrument)

        """

        price = self.parent.rawdata.get_daily_prices(instrument_code)
        vol = self.parent.rawdata.daily_returns_volatility(instrument_code)
        raw_position = self.get_subsystem_position_preliminary(instrument_code)

        subsystem_position = stoploss(price, vol, raw_position, dynamic_vol=self.parent.config.dynamic_vol,
                                      dynamic_SL = self.parent.config.dynamic_SL)

        return subsystem_position


simple_mav_rule = TradingRule(
    dict(function=simple_mav, other_args=dict(long=40, short=10))
)

data = csvFuturesSimData()



## trade by trade p&l
## only works at subsystem level

def system_given_flags(dynamic_vol = False, dynamic_SL = False):
    config = Config(
        dict(
            trading_rules=dict(simple_mav=simple_mav_rule),
            percentage_vol_target=16.0,
            notional_trading_capital=100000000,
            dynamic_vol=dynamic_vol,
            dynamic_SL=dynamic_SL
        )
    )

    system = System(
        [
            Account(),
            Portfolios(),
            PositionSizeWithStopLoss(),
            FuturesRawData(),
            ForecastCombine(),
            ForecastScaleCap(),
            Rules(simple_mav_rule),
        ],
        data,
        config,
    )
    system.set_logging_level("on")

    return system



def stats(stacked_returns):
    stacked_returns_pandl, stacked_trades_pandl = stacked_returns

    print("SR %f" % sharpe_for_stacked(stacked_returns_pandl))
    print("Skew trades %f" % skew_for_stacked(stacked_trades_pandl))
    print("Skew daily returns %f" % skew_for_stacked(stacked_returns_pandl))
    print("Skew weekly returns %f" % skew_for_stacked(stacked_returns_pandl, period="1W"))
    print("Skew monthly returns %f" % skew_for_stacked(stacked_returns_pandl, period="1M"))


def stacked_returns_over_instrument(system):

    return_list = []
    for instrument in system.get_instrument_list():
        returns = calc_returns_for_system_and_code(instrument, system)
        return_list.append(returns)

    stacked_returns_pandl = [x[0] for x in return_list]
    stacked_trades_pandl = [x[1] for x in return_list]

    return stacked_returns_pandl, stacked_trades_pandl



def stack_to_df(stacked_returns, period=None):
    if period is not None:
        new_stacked_returns = [returns.resample(period).sum() for returns in stacked_returns]
    else:
        new_stacked_returns = stacked_returns

    df_returns = pd.concat(new_stacked_returns, axis=0)

    return df_returns


def calc_returns_for_system_and_code(instrument_code: str, system: System):
    pandl_returns_capital = pandl_capital(instrument_code, system, method_used="returns")
    pandl_trades_capital = pandl_capital(instrument_code, system, method_used="trades")

    return pandl_returns_capital, pandl_trades_capital

def sharpe_for_stacked(stacked_returns_pandl):
    sharpe_list = [sharpe(pandl_series_capital) for pandl_series_capital in stacked_returns_pandl]
    return np.median(sharpe_list)

def sharpe(pandl_series_capital):
    avg = pandl_series_capital.mean()
    stdev = pandl_series_capital.std()

    return 16* avg / stdev

def skew_for_stacked(stacked_returns_pandl, period="1B"):
    resampled = [pandl_series_capital.resample(period) for pandl_series_capital in stacked_returns_pandl]
    skew_list = [pandl_series_capital.skew() for pandl_series_capital in resampled]
    return np.median(skew_list)

def pandl_capital(instrument_code: str, system: System, method_used: str = "returns"):
    pandl_series_money = pandl_money(instrument_code, system, method_used=method_used)
    capital = system.config.notional_trading_capital

    return pandl_series_money / capital

def pandl_money(instrument_code: str, system: System, method_used: str= "returns"):
    pos_series = system.positionSize.get_subsystem_position(instrument_code)
    price_series = system.rawdata.get_daily_prices(instrument_code)
    block_size =system.data.get_value_of_block_price_move(instrument_code)
    fx =system.positionSize.get_fx_rate(instrument_code)

    ans = pandl_base(price_series, pos_series, block_size, fx, method_used = method_used)

    return ans

def pandl_base(price_series: pd.Series, pos_series: pd.DataFrame, block_size: float, fx: pd.Series,
               method_used = "returns"):
    pandl_series_local = pandl_local_ccy(price_series, pos_series, block_size, method_used = method_used)
    fx_matching = fx.reindex(pandl_series_local.index).ffill()

    return pandl_series_local * fx_matching

def pandl_local_ccy(price_series, pos_series, block_size, method_used = "returns"):
    if method_used == "returns":
        pandl_series_points =pandl_returns_points(price_series,  pos_series)
    else:
        ## trades
        pandl_series_points = pandl_trades_points(price_series, pos_series)

    return pandl_series_points * block_size

def pandl_returns_points(price_series, pos_series):
    """
    Calculate pandl for an individual position


    :param price: price series
    :type price: Tx1 pd.Series

    :param trade_series: set of trades done  NOT always aligned to price can be length 0
    :type trade_series: Tx2 pd.DataFrame columns ['qty', 'price']

    :param pos_series: series of positions NOT ALWAYS aligned to price
    :type pos_series: Tx1 pd.Series

    :returns: pd.Series

    """

    # want to have both kinds of price
    price_series = price_series.reindex(pos_series.index, method="ffill")
    price_returns = price_series.diff()
    returns = pos_series.shift(1) * price_returns

    return returns


def pandl_trades_points(price_series, pos_series):
    """
    :returns: pd.Series, only dates when we're trading

    """

    # want to have both kinds of price
    returns = pandl_returns_points(price_series, pos_series)
    trade_dates_idx = get_trade_dates_idx_from_pos_series(pos_series)
    trade_pandl = [sum_between_trade_dates(trade_dates_idx, idx, returns) for idx in range(len(trade_dates_idx))]

    trade_returns = pd.Series(trade_pandl, index = returns.index[trade_dates_idx])

    return trade_returns

def get_trade_dates_idx_from_pos_series(pos_series):
    prev_position = pos_series.shift(1)
    trade_dates_idx = [idx for idx, _index_date in enumerate(list(pos_series.index))
              if traded(pos_series, prev_position, idx)]
    if trade_dates_idx[-1]<len(pos_series)-1:
        trade_dates_idx.append(len(pos_series)-1)

    return trade_dates_idx

def traded(pos_series, prev_position, idx):
    if sign(pos_series[idx]) != sign(prev_position[idx]):
        return True
    else:
        return False

def sum_between_trade_dates(trade_dates_idx, idx, returns):
    if idx==0:
        previous_date_idx = 0
    else:
        previous_date_idx = trade_dates_idx[idx-1]

    current_idx = trade_dates_idx[idx]

    return returns[previous_date_idx: current_idx].sum()


system = system_given_flags(dynamic_vol=True, dynamic_SL=True)
stacked_returns = stacked_returns_over_instrument(system)
stats(stacked_returns)