def init_instance_fixtures(self):
super(TestRisk, self).init_instance_fixtures()
start_date = datetime.datetime(year=2006,
month=1,
day=1,
hour=0,
minute=0,
tzinfo=pytz.utc)
end_date = datetime.datetime(year=2006,
month=12,
day=29,
tzinfo=pytz.utc)
self.sim_params = SimulationParameters(
period_start=start_date,
period_end=end_date,
trading_schedule=self.trading_schedule,
)
self.algo_returns_06 = factory.create_returns_from_list(
answer_key.ALGORITHM_RETURNS.values, self.sim_params)
self.cumulative_metrics_06 = risk.RiskMetricsCumulative(
self.sim_params,
treasury_curves=self.env.treasury_curves,
trading_schedule=self.trading_schedule,
)
for dt, returns in answer_key.RETURNS_DATA.iterrows():
self.cumulative_metrics_06.update(dt, returns['Algorithm Returns'],
returns['Benchmark Returns'],
0.0)
def setUp(self):
start_date = datetime.datetime(
year=2006,
month=1,
day=1,
hour=0,
minute=0,
tzinfo=pytz.utc)
end_date = datetime.datetime(
year=2006, month=12, day=29, tzinfo=pytz.utc)
self.sim_params = SimulationParameters(
period_start=start_date,
period_end=end_date
)
self.algo_returns_06 = factory.create_returns_from_list(
answer_key.ALGORITHM_RETURNS.values,
self.sim_params
)
self.cumulative_metrics_06 = risk.RiskMetricsCumulative(
self.sim_params)
for dt, returns in answer_key.RETURNS_DATA.iterrows():
self.cumulative_metrics_06.update(dt,
returns['Algorithm Returns'],
returns['Benchmark Returns'])
def handle_intraday_close(self, new_mkt_open, new_mkt_close):
# update_performance should have been called in handle_minute_close
# so it is not repeated here.
self.intraday_risk_metrics = \
risk.RiskMetricsCumulative(self.sim_params)
# increment the day counter before we move markers forward.
self.day_count += 1.0
self.market_open = new_mkt_open
self.market_close = new_mkt_close
def handle_intraday_close(self):
self.intraday_risk_metrics = \
risk.RiskMetricsCumulative(self.sim_params)
# increment the day counter before we move markers forward.
self.day_count += 1.0
# move the market day markers forward
if self.market_close < trading.environment.last_trading_day:
self.market_open, self.market_close = \
trading.environment.next_open_and_close(self.market_open)
else:
self.market_close = self.sim_params.last_close
def handle_intraday_close(self):
# update_performance should have been called in handle_minute_close
# so it is not repeated here.
self.intraday_risk_metrics = \
risk.RiskMetricsCumulative(self.sim_params)
# increment the day counter before we move markers forward.
self.day_count += 1.0
# move the market day markers forward
if self.market_close < trading.environment.last_trading_day:
self.market_open, self.market_close = \
trading.environment.next_open_and_close(self.market_open)
else:
self.market_close = self.sim_params.last_close
def test_minute_risk(self):
risk_metrics = risk.RiskMetricsCumulative(self.sim_params)
first_dt = self.sim_params.first_open
second_dt = self.sim_params.first_open + datetime.timedelta(minutes=1)
risk_metrics.update(first_dt, 1.0, 2.0)
self.assertEquals(1, len(risk_metrics.alpha))
risk_metrics.update(second_dt, 3.0, 4.0)
self.assertEquals(2, len(risk_metrics.alpha))
def handle_intraday_market_close(self, new_mkt_open, new_mkt_close):
"""
Function called at market close only when emitting at minutely
frequency.
"""
# update_performance should have been called in handle_minute_close
# so it is not repeated here.
self.intraday_risk_metrics = \
risk.RiskMetricsCumulative(self.sim_params)
# increment the day counter before we move markers forward.
self.day_count += 1.0
self.market_open = new_mkt_open
self.market_close = new_mkt_close
self.account_needs_update = True
def test_minute_risk(self):
risk_metrics = risk.RiskMetricsCumulative(self.sim_params)
first_dt = self.sim_params.first_open
second_dt = self.sim_params.first_open + datetime.timedelta(minutes=1)
account = {'leverage': 0.0}
risk_metrics.update(first_dt, 1.0, 2.0, account)
self.assertEquals(1, len(risk_metrics.metrics.alpha.valid()))
risk_metrics.update(second_dt, 3.0, 4.0, account)
self.assertEquals(2, len(risk_metrics.metrics.alpha.valid()))
def init_instance_fixtures(self):
super(TestRisk, self).init_instance_fixtures()
start_session = pd.Timestamp("2006-01-01", tz='UTC')
end_session = pd.Timestamp("2006-12-29", tz='UTC')
self.sim_params = SimulationParameters(
start_session=start_session,
end_session=end_session,
trading_calendar=self.trading_calendar,
)
self.algo_returns = factory.create_returns_from_list(
RETURNS, self.sim_params)
self.cumulative_metrics = risk.RiskMetricsCumulative(
self.sim_params,
trading_calendar=self.trading_calendar,
)
for dt, returns in self.algo_returns.iteritems():
self.cumulative_metrics.update(dt, returns, BENCHMARK_BASE, 0.0)
def __init__(self, sim_params, env=None):
self.sim_params = sim_params
self.period_start = self.sim_params.period_start
self.period_end = self.sim_params.period_end
self.last_close = self.sim_params.last_close
first_day = self.sim_params.first_open
self.market_open, self.market_close = \
trading.environment.get_open_and_close(first_day)
self.total_days = self.sim_params.days_in_period
self.capital_base = self.sim_params.capital_base
self.emission_rate = self.sim_params.emission_rate
all_trading_days = trading.environment.trading_days
mask = ((all_trading_days >= normalize_date(self.period_start)) &
(all_trading_days <= normalize_date(self.period_end)))
self.trading_days = all_trading_days[mask]
self.dividend_frame = pd.DataFrame()
self._dividend_count = 0
self.position_tracker = PositionTracker()
self.perf_periods = []
if self.emission_rate == 'daily':
self.all_benchmark_returns = pd.Series(index=self.trading_days)
self.intraday_risk_metrics = None
self.cumulative_risk_metrics = \
risk.RiskMetricsCumulative(self.sim_params)
elif self.emission_rate == 'minute':
self.all_benchmark_returns = pd.Series(
index=pd.date_range(self.sim_params.first_open,
self.sim_params.last_close,
freq='Min'))
self.intraday_risk_metrics = \
risk.RiskMetricsCumulative(self.sim_params)
self.cumulative_risk_metrics = \
risk.RiskMetricsCumulative(self.sim_params,
returns_frequency='daily',
create_first_day_stats=True)
self.minute_performance = PerformancePeriod(
# initial cash is your capital base.
self.capital_base,
# the cumulative period will be calculated over the
# entire test.
self.period_start,
self.period_end,
# don't save the transactions for the cumulative
# period
keep_transactions=False,
keep_orders=False,
# don't serialize positions for cumualtive period
serialize_positions=False)
self.minute_performance.position_tracker = self.position_tracker
self.perf_periods.append(self.minute_performance)
# this performance period will span the entire simulation from
# inception.
self.cumulative_performance = PerformancePeriod(
# initial cash is your capital base.
self.capital_base,
# the cumulative period will be calculated over the entire test.
self.period_start,
self.period_end,
# don't save the transactions for the cumulative
# period
keep_transactions=False,
keep_orders=False,
# don't serialize positions for cumualtive period
serialize_positions=False,
)
self.cumulative_performance.position_tracker = self.position_tracker
self.perf_periods.append(self.cumulative_performance)
# this performance period will span just the current market day
self.todays_performance = PerformancePeriod(
# initial cash is your capital base.
self.capital_base,
# the daily period will be calculated for the market day
self.market_open,
self.market_close,
keep_transactions=True,
keep_orders=True,
serialize_positions=True,
)
self.todays_performance.position_tracker = self.position_tracker
self.perf_periods.append(self.todays_performance)
self.saved_dt = self.period_start
self.returns = pd.Series(index=self.trading_days)
# one indexed so that we reach 100%
self.day_count = 0.0
self.txn_count = 0
self.event_count = 0
def __init__(self, sim_params, env):
self.sim_params = sim_params
self.env = env
self.period_start = self.sim_params.period_start
self.period_end = self.sim_params.period_end
self.last_close = self.sim_params.last_close
first_open = self.sim_params.first_open.tz_convert(
self.env.exchange_tz
)
self.day = pd.Timestamp(datetime(first_open.year, first_open.month,
first_open.day), tz='UTC')
self.market_open, self.market_close = env.get_open_and_close(self.day)
self.total_days = self.sim_params.days_in_period
self.capital_base = self.sim_params.capital_base
self.emission_rate = sim_params.emission_rate
all_trading_days = env.trading_days
mask = ((all_trading_days >= normalize_date(self.period_start)) &
(all_trading_days <= normalize_date(self.period_end)))
self.trading_days = all_trading_days[mask]
self.dividend_frame = pd.DataFrame()
self._dividend_count = 0
self.position_tracker = PositionTracker(asset_finder=env.asset_finder)
if self.emission_rate == 'daily':
self.all_benchmark_returns = pd.Series(
index=self.trading_days)
self.cumulative_risk_metrics = \
risk.RiskMetricsCumulative(self.sim_params, self.env)
elif self.emission_rate == 'minute':
self.all_benchmark_returns = pd.Series(index=pd.date_range(
self.sim_params.first_open, self.sim_params.last_close,
freq='Min'))
self.cumulative_risk_metrics = \
risk.RiskMetricsCumulative(self.sim_params, self.env,
create_first_day_stats=True)
# this performance period will span the entire simulation from
# inception.
self.cumulative_performance = PerformancePeriod(
# initial cash is your capital base.
starting_cash=self.capital_base,
# the cumulative period will be calculated over the entire test.
period_open=self.period_start,
period_close=self.period_end,
# don't save the transactions for the cumulative
# period
keep_transactions=False,
keep_orders=False,
# don't serialize positions for cumualtive period
serialize_positions=False,
asset_finder=self.env.asset_finder,
)
self.cumulative_performance.position_tracker = self.position_tracker
# this performance period will span just the current market day
self.todays_performance = PerformancePeriod(
# initial cash is your capital base.
starting_cash=self.capital_base,
# the daily period will be calculated for the market day
period_open=self.market_open,
period_close=self.market_close,
keep_transactions=True,
keep_orders=True,
serialize_positions=True,
asset_finder=self.env.asset_finder,
)
self.todays_performance.position_tracker = self.position_tracker
self.saved_dt = self.period_start
# one indexed so that we reach 100%
self.day_count = 0.0
self.txn_count = 0
self.account_needs_update = True
self._account = None
def __init__(self, sim_params, trading_calendar, env):
self.sim_params = sim_params
self.trading_calendar = trading_calendar
self.asset_finder = env.asset_finder
self.treasury_curves = env.treasury_curves
self.period_start = self.sim_params.start_session
self.period_end = self.sim_params.end_session
self.last_close = self.sim_params.last_close
self._current_session = self.sim_params.start_session
self.market_open, self.market_close = \
self.trading_calendar.open_and_close_for_session(
self._current_session
)
self.total_session_count = len(self.sim_params.sessions)
self.capital_base = self.sim_params.capital_base
self.emission_rate = sim_params.emission_rate
self.position_tracker = PositionTracker(
asset_finder=env.asset_finder,
data_frequency=self.sim_params.data_frequency)
if self.emission_rate == 'daily':
self.all_benchmark_returns = pd.Series(
index=self.sim_params.sessions)
self.cumulative_risk_metrics = \
risk.RiskMetricsCumulative(
self.sim_params,
self.treasury_curves,
self.trading_calendar
)
elif self.emission_rate == 'minute':
self.all_benchmark_returns = pd.Series(
index=pd.date_range(self.sim_params.first_open,
self.sim_params.last_close,
freq='Min'))
self.cumulative_risk_metrics = \
risk.RiskMetricsCumulative(
self.sim_params,
self.treasury_curves,
self.trading_calendar,
create_first_day_stats=True
)
# this performance period will span the entire simulation from
# inception.
self.cumulative_performance = PerformancePeriod(
# initial cash is your capital base.
starting_cash=self.capital_base,
data_frequency=self.sim_params.data_frequency,
# the cumulative period will be calculated over the entire test.
period_open=self.period_start,
period_close=self.period_end,
# don't save the transactions for the cumulative
# period
keep_transactions=False,
keep_orders=False,
# don't serialize positions for cumulative period
serialize_positions=False,
asset_finder=self.asset_finder,
name="Cumulative")
self.cumulative_performance.position_tracker = self.position_tracker
# this performance period will span just the current market day
self.todays_performance = PerformancePeriod(
# initial cash is your capital base.
starting_cash=self.capital_base,
data_frequency=self.sim_params.data_frequency,
# the daily period will be calculated for the market day
period_open=self.market_open,
period_close=self.market_close,
keep_transactions=True,
keep_orders=True,
serialize_positions=True,
asset_finder=self.asset_finder,
name="Daily")
self.todays_performance.position_tracker = self.position_tracker
self.saved_dt = self.period_start
# one indexed so that we reach 100%
self.session_count = 0.0
self.txn_count = 0
self.account_needs_update = True
self._account = None
