def init_instance_fixtures(self):
super(TestRisk, self).init_instance_fixtures()
self.start_session = pd.Timestamp("2006-01-01", tz='UTC')
self.end_session = self.trading_calendar.minute_to_session_label(
pd.Timestamp("2006-12-31", tz='UTC'),
direction="previous"
)
self.sim_params = SimulationParameters(
start_session=self.start_session,
end_session=self.end_session,
trading_calendar=self.trading_calendar,
)
self.algo_returns = factory.create_returns_from_list(
RETURNS,
self.sim_params
)
self.benchmark_returns = factory.create_returns_from_list(
BENCHMARK,
self.sim_params
)
self.metrics = risk.RiskReport(
self.algo_returns,
self.sim_params,
benchmark_returns=self.benchmark_returns,
trading_calendar=self.trading_calendar,
treasury_curves=self.env.treasury_curves,
)
def init_instance_fixtures(self):
super(TestRisk, self).init_instance_fixtures()
self.start_session = pd.Timestamp("2006-01-01", tz='UTC')
self.end_session = self.trading_calendar.minute_to_session_label(
pd.Timestamp("2006-12-31", tz='UTC'),
direction="previous"
)
self.sim_params = SimulationParameters(
start_session=self.start_session,
end_session=self.end_session,
trading_calendar=self.trading_calendar,
)
self.algo_returns = factory.create_returns_from_list(
RETURNS,
self.sim_params
)
self.benchmark_returns = factory.create_returns_from_list(
BENCHMARK,
self.sim_params
)
self.metrics = ClassicRiskMetrics.risk_report(
algorithm_returns=self.algo_returns,
benchmark_returns=self.benchmark_returns,
algorithm_leverages=pd.Series(0.0, index=self.algo_returns.index)
)
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 test_drawdown(self):
returns = factory.create_returns_from_list([1.0, -0.5, 0.8, 0.17, 1.0, -0.1, -0.45], self.sim_params)
# 200, 100, 180, 210.6, 421.2, 379.8, 208.494
metrics = risk.RiskMetricsPeriod(
returns.index[0], returns.index[-1], returns, env=self.env, benchmark_returns=self.env.benchmark_returns
)
self.assertEqual(metrics.max_drawdown, 0.505)
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 test_factory(self):
returns = [0.1] * 100
r_objects = factory.create_returns_from_list(returns, self.sim_params)
self.assertLessEqual(
r_objects.index[-1],
pd.Timestamp('2006-12-31', tz='UTC')
)
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 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 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=31,
tzinfo=pytz.utc)
self.sim_params = SimulationParameters(period_start=start_date,
period_end=end_date)
self.algo_returns_06 = factory.create_returns_from_list(
RETURNS, self.sim_params)
self.metrics_06 = risk.RiskReport(self.algo_returns_06,
self.sim_params)
start_08 = datetime.datetime(year=2008,
month=1,
day=1,
hour=0,
minute=0,
tzinfo=pytz.utc)
end_08 = datetime.datetime(year=2008,
month=12,
day=31,
tzinfo=pytz.utc)
self.sim_params08 = SimulationParameters(period_start=start_08,
period_end=end_08)
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,
treasury_curves=self.env.treasury_curves,
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_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_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_calendar=self.trading_calendar,
)
for dt, returns in answer_key.RETURNS_DATA.iterrows():
self.cumulative_metrics_06.update(dt,
returns['Algorithm Returns'],
returns['Benchmark Returns'],
0.0)
def test_drawdown(self):
returns = factory.create_returns_from_list(
[1.0, -0.5, 0.8, .17, 1.0, -0.1, -0.45], self.sim_params)
#200, 100, 180, 210.6, 421.2, 379.8, 208.494
metrics = risk.RiskMetricsBatch(returns[0].date, returns[-1].date,
returns)
self.assertEqual(metrics.max_drawdown, 0.505)
def test_drawdown(self):
returns = factory.create_returns_from_list(
[1.0, -0.5, 0.8, .17, 1.0, -0.1, -0.45], self.sim_params)
#200, 100, 180, 210.6, 421.2, 379.8, 208.494
metrics = risk.RiskMetricsBatch(returns[0].date,
returns[-1].date,
returns)
self.assertEqual(metrics.max_drawdown, 0.505)
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=31, tzinfo=pytz.utc)
self.benchmark_returns, self.treasury_curves = \
factory.load_market_data()
self.trading_env = TradingEnvironment(
self.benchmark_returns,
self.treasury_curves,
period_start=start_date,
period_end=end_date
)
self.onesec = datetime.timedelta(seconds=1)
self.oneday = datetime.timedelta(days=1)
self.tradingday = datetime.timedelta(hours=6, minutes=30)
self.dt = datetime.datetime.utcnow()
self.algo_returns_06 = factory.create_returns_from_list(
RETURNS,
self.trading_env
)
self.metrics_06 = risk.RiskReport(
self.algo_returns_06,
self.trading_env
)
start_08 = datetime.datetime(
year=2008,
month=1,
day=1,
hour=0,
minute=0,
tzinfo=pytz.utc)
end_08 = datetime.datetime(
year=2008,
month=12,
day=31,
tzinfo=pytz.utc
)
self.trading_env08 = TradingEnvironment(
self.benchmark_returns,
self.treasury_curves,
period_start=start_08,
period_end=end_08
)
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=31, tzinfo=pytz.utc)
self.benchmark_returns, self.treasury_curves = \
factory.load_market_data()
self.trading_env = TradingEnvironment(
self.benchmark_returns,
self.treasury_curves,
period_start=start_date,
period_end=end_date
)
self.onesec = datetime.timedelta(seconds=1)
self.oneday = datetime.timedelta(days=1)
self.tradingday = datetime.timedelta(hours=6, minutes=30)
self.dt = datetime.datetime.utcnow()
self.algo_returns_06 = factory.create_returns_from_list(
RETURNS,
self.trading_env
)
self.metrics_06 = risk.RiskReport(
self.algo_returns_06,
self.trading_env
)
start_08 = datetime.datetime(
year=2008,
month=1,
day=1,
hour=0,
minute=0,
tzinfo=pytz.utc)
end_08 = datetime.datetime(
year=2008,
month=12,
day=31,
tzinfo=pytz.utc
)
self.trading_env08 = TradingEnvironment(
self.benchmark_returns,
self.treasury_curves,
period_start=start_08,
period_end=end_08
)
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=31, 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(
RETURNS,
self.sim_params
)
self.benchmark_returns_06 = \
answer_key.RETURNS_DATA['Benchmark Returns']
self.metrics_06 = risk.RiskReport(
self.algo_returns_06,
self.sim_params,
benchmark_returns=self.benchmark_returns_06,
trading_schedule=self.trading_schedule,
treasury_curves=self.env.treasury_curves,
)
start_08 = datetime.datetime(
year=2008,
month=1,
day=1,
hour=0,
minute=0,
tzinfo=pytz.utc)
end_08 = datetime.datetime(
year=2008,
month=12,
day=31,
tzinfo=pytz.utc
)
self.sim_params08 = SimulationParameters(
period_start=start_08,
period_end=end_08,
trading_schedule=self.trading_schedule,
)
def test_sharpe_value_when_benchmark_null(self):
# Sharpe is displayed as '0.0' instead of np.nan
null_returns = factory.create_returns_from_list([0.0] * 251,
self.sim_params)
test_period = ClassicRiskMetrics.risk_metric_period(
start_session=self.start_session,
end_session=self.end_session,
algorithm_returns=null_returns,
benchmark_returns=null_returns,
algorithm_leverages=pd.Series(0.0, index=self.algo_returns.index))
self.assertEqual(test_period['sharpe'], 0.0)
def init_instance_fixtures(self):
super(TestRisk, self).init_instance_fixtures()
self.start_session = pd.Timestamp("2006-01-01", tz='UTC')
self.end_session = self.trading_calendar.minute_to_session_label(
pd.Timestamp("2006-12-31", tz='UTC'), direction="previous")
self.sim_params = SimulationParameters(
start_session=self.start_session,
end_session=self.end_session,
trading_calendar=self.trading_calendar,
)
self.algo_returns = factory.create_returns_from_list(
RETURNS, self.sim_params)
self.benchmark_returns = factory.create_returns_from_list(
BENCHMARK, self.sim_params)
self.metrics = risk.RiskReport(
self.algo_returns,
self.sim_params,
benchmark_returns=self.benchmark_returns,
trading_calendar=self.trading_calendar,
treasury_curves=self.env.treasury_curves,
)
def test_drawdown(self):
returns = factory.create_returns_from_list(
[1.0, -0.5, 0.8, .17, 1.0, -0.1, -0.45], self.sim_params)
# 200, 100, 180, 210.6, 421.2, 379.8, 208.494
metrics = risk.RiskMetricsPeriod(
returns.index[0],
returns.index[-1],
returns,
env=self.env,
benchmark_returns=self.env.benchmark_returns,
)
self.assertEqual(metrics.max_drawdown, 0.505)
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=31, tzinfo=pytz.utc)
self.sim_params = SimulationParameters(
period_start=start_date,
period_end=end_date,
env=self.env,
)
self.algo_returns_06 = factory.create_returns_from_list(
RETURNS,
self.sim_params
)
self.benchmark_returns_06 = \
answer_key.RETURNS_DATA['Benchmark Returns']
self.metrics_06 = risk.RiskReport(
self.algo_returns_06,
self.sim_params,
benchmark_returns=self.benchmark_returns_06,
env=self.env,
)
start_08 = datetime.datetime(
year=2008,
month=1,
day=1,
hour=0,
minute=0,
tzinfo=pytz.utc)
end_08 = datetime.datetime(
year=2008,
month=12,
day=31,
tzinfo=pytz.utc
)
self.sim_params08 = SimulationParameters(
period_start=start_08,
period_end=end_08,
env=self.env,
)
def test_sharpe_value_when_null(self):
# Sharpe is displayed as '0.0' instead of np.nan
null_returns = factory.create_returns_from_list([0.0] * 251,
self.sim_params)
test_period = RiskMetricsPeriod(
start_session=self.start_session,
end_session=self.end_session,
returns=null_returns,
benchmark_returns=self.benchmark_returns,
trading_calendar=self.trading_calendar,
treasury_curves=self.env.treasury_curves,
)
assert test_period.sharpe == 0.0
def compute_full(results, sim_params):
returns_risk = create_returns_from_list([ret for ret in results.returns],
sim_params)
# Compute metrics for the entire backtesting period
riskMetrics = RiskMetricsPeriod(sim_params.first_open,
sim_params.last_close, returns_risk)
# Compute RiskMetricsBase on a rolling basis for several terms.
riskReport = RiskReport(returns_risk, sim_params)
return riskReport, riskMetrics
def test_sharpe_value_when_null(self):
# Sharpe is displayed as '0.0' instead of np.nan
null_returns = factory.create_returns_from_list(
[0.0]*251,
self.sim_params
)
test_period = RiskMetricsPeriod(
start_session=self.start_session,
end_session=self.end_session,
returns=null_returns,
benchmark_returns=self.benchmark_returns,
trading_calendar=self.trading_calendar,
)
assert test_period.sharpe == 0.0
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=31,
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(
RETURNS, self.sim_params)
self.benchmark_returns_06 = \
answer_key.RETURNS_DATA['Benchmark Returns']
self.metrics_06 = risk.RiskReport(
self.algo_returns_06,
self.sim_params,
benchmark_returns=self.benchmark_returns_06,
trading_schedule=self.trading_schedule,
treasury_curves=self.env.treasury_curves,
)
start_08 = datetime.datetime(year=2008,
month=1,
day=1,
hour=0,
minute=0,
tzinfo=pytz.utc)
end_08 = datetime.datetime(year=2008,
month=12,
day=31,
tzinfo=pytz.utc)
self.sim_params08 = SimulationParameters(
period_start=start_08,
period_end=end_08,
trading_schedule=self.trading_schedule,
)
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=31, tzinfo=pytz.utc)
self.sim_params = SimulationParameters(
period_start=start_date,
period_end=end_date
)
self.onesec = datetime.timedelta(seconds=1)
self.oneday = datetime.timedelta(days=1)
self.tradingday = datetime.timedelta(hours=6, minutes=30)
self.dt = datetime.datetime.utcnow()
self.algo_returns_06 = factory.create_returns_from_list(
RETURNS,
self.sim_params
)
self.metrics_06 = risk.RiskReport(
self.algo_returns_06,
self.sim_params
)
start_08 = datetime.datetime(
year=2008,
month=1,
day=1,
hour=0,
minute=0,
tzinfo=pytz.utc)
end_08 = datetime.datetime(
year=2008,
month=12,
day=31,
tzinfo=pytz.utc
)
self.sim_params08 = SimulationParameters(
period_start=start_08,
period_end=end_08
)
def test_sharpe_value_when_null(self):
# Sharpe is displayed as '0.0' instead of np.nan
null_returns = factory.create_returns_from_list(
[0.0]*251,
self.sim_params
)
test_period = ClassicRiskMetrics.risk_metric_period(
start_session=self.start_session,
end_session=self.end_session,
algorithm_returns=null_returns,
benchmark_returns=self.benchmark_returns,
algorithm_leverages=pd.Series(
0.0,
index=self.algo_returns.index
)
)
self.assertEqual(test_period['sharpe'], 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=31, tzinfo=pytz.utc)
self.sim_params = SimulationParameters(
period_start=start_date,
period_end=end_date
)
self.algo_returns_06 = factory.create_returns_from_list(
RETURNS,
self.sim_params
)
self.metrics_06 = risk.RiskReport(
self.algo_returns_06,
self.sim_params
)
start_08 = datetime.datetime(
year=2008,
month=1,
day=1,
hour=0,
minute=0,
tzinfo=pytz.utc)
end_08 = datetime.datetime(
year=2008,
month=12,
day=31,
tzinfo=pytz.utc
)
self.sim_params08 = SimulationParameters(
period_start=start_08,
period_end=end_08
)
def test_index_mismatch_exception(self):
# An exception is raised when returns and benchmark returns
# have indexes that do not match
bench_params = SimulationParameters(
start_session=pd.Timestamp("2006-02-01", tz='UTC'),
end_session=pd.Timestamp("2006-02-28", tz='UTC'),
trading_calendar=self.trading_calendar,
)
benchmark = factory.create_returns_from_list([BENCHMARK_BASE] * 19,
bench_params)
with np.testing.assert_raises(Exception):
RiskMetricsPeriod(
start_session=self.start_session,
end_session=self.end_session,
returns=self.algo_returns,
benchmark_returns=benchmark,
trading_calendar=self.trading_calendar,
treasury_curves=self.env.treasury_curves,
)
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 test_index_mismatch_exception(self):
# An exception is raised when returns and benchmark returns
# have indexes that do not match
bench_params = SimulationParameters(
start_session=pd.Timestamp("2006-02-01", tz='UTC'),
end_session=pd.Timestamp("2006-02-28", tz='UTC'),
trading_calendar=self.trading_calendar,
)
benchmark = factory.create_returns_from_list(
[BENCHMARK_BASE]*19,
bench_params
)
with np.testing.assert_raises(Exception):
RiskMetricsPeriod(
start_session=self.start_session,
end_session=self.end_session,
returns=self.algo_returns,
benchmark_returns=benchmark,
trading_calendar=self.trading_calendar,
)
def compute(results, sim_params):
trading_dates = results.index
idx = np.where(trading_dates.year[0:-1] != trading_dates.year[1:])[0]
# include the last element for the most recent year
idx_last = trading_dates.shape[0] - 1
if idx_last not in idx:
idx = np.append(idx, idx_last)
returns_risk = create_returns_from_list([ret for ret in results.returns],
sim_params)
dt_ranges = []
yoy_metrics = []
for i in range(len(idx)):
if i == 0:
tBeg = trading_dates[0].tz_localize('UTC')
else:
tBeg = trading_dates[idx[i - 1]].tz_localize('UTC')
tEnd = trading_dates[idx[i]].tz_localize('UTC')
dt_ranges.append([tBeg, tEnd, tEnd.year])
# append full range
dt_ranges.append([
trading_dates[0].tz_localize('UTC'),
trading_dates[-1].tz_localize('UTC'), 'All'
])
for rng in dt_ranges:
(tBeg, tEnd, year) = rng
metrics = None
try:
metrics = RiskMetricsPeriod(tBeg, tEnd, returns_risk)
dMetrics = metrics.to_dict()
dMetrics['year'] = year
yoy_metrics.append(dMetrics)
except Exception, e:
print e
yoy_metrics.append({'year': year})
def test_factory(self):
returns = [0.1] * 100
r_objects = factory.create_returns_from_list(returns, self.trading_env)
self.assertTrue(r_objects[-1].date <=
datetime.datetime(
year=2006, month=12, day=31, tzinfo=pytz.utc))
def test_factory(self):
returns = [0.1] * 100
r_objects = factory.create_returns_from_list(returns, self.sim_params)
self.assertTrue(r_objects[-1].date <=
datetime.datetime(
year=2006, month=12, day=31, tzinfo=pytz.utc))
def test_factory(self):
returns = [0.1] * 100
r_objects = factory.create_returns_from_list(returns, self.sim_params)
assert r_objects.index[-1] <= pd.Timestamp("2006-12-31", tz="UTC")
def test_factory(self):
returns = [0.1] * 100
r_objects = factory.create_returns_from_list(returns, self.sim_params)
self.assertTrue(r_objects.index[-1] <=
datetime.datetime(
year=2006, month=12, day=31, tzinfo=pytz.utc))
self.day_count += 1
if __name__ == '__main__':
data = load_bars_from_yahoo(stocks=sym_list, indexes={}, start=start, end=end)
trend_trader = trend_trader()
results = trend_trader.run(data)
###########################################################################
# Generate metrics
print 'Generating Risk Report...........'
print 'Using S&P500 as benchmark........'
start = results.first_valid_index().replace(tzinfo=pytz.utc)
end = results.last_valid_index().replace(tzinfo=pytz.utc)
env = trading.SimulationParameters(start, end)
returns_risk = create_returns_from_list(results.returns, env)
algo_returns = RiskMetricsBase(start, end, returns_risk).algorithm_period_returns
benchmark_returns = RiskMetricsBase(start, end, returns_risk).benchmark_period_returns
excess_return = RiskMetricsBase(start, end, returns_risk).excess_return
algo_volatility = RiskMetricsBase(start, end, returns_risk).algorithm_volatility
benchmark_volatility = RiskMetricsBase(start, end, returns_risk).benchmark_volatility
sharpe = RiskMetricsBase(start, end, returns_risk).sharpe
sortino = RiskMetricsBase(start, end, returns_risk).sortino
information = RiskMetricsBase(start, end, returns_risk).information
beta = RiskMetricsBase(start, end, returns_risk).beta
alpha = RiskMetricsBase(start, end, returns_risk).alpha
max_drawdown = RiskMetricsBase(start, end, returns_risk).max_drawdown
print '---------Risk Metrics---------'
print 'Algorithm Returns: ' + str(round(algo_returns * 100,4)) + '%'
tzinfo=pytz.UTC),
10000,
emission_rate='daily')
sim_params_minute = SimulationParameters(datetime.datetime(2013,
6,
19,
tzinfo=pytz.UTC),
datetime.datetime(2013,
6,
19,
tzinfo=pytz.UTC),
10000,
emission_rate='minute')
returns = factory.create_returns_from_list([1.0], sim_params_daily)
argument_list = [
(Blotter, ()), (Order, (datetime.datetime(2013, 6,
19), 8554, 100)), (PerShare, ()),
(PerTrade, ()), (PerDollar, ()), (PerformancePeriod, (10000, )),
(Position, (8554, )), (PositionTracker, ()),
(PerformanceTracker, (sim_params_minute, )),
(RiskMetricsCumulative, (sim_params_minute, )),
(RiskMetricsPeriod, (returns.index[0], returns.index[0], returns)),
(RiskReport, (returns, sim_params_minute)), (FixedSlippage, ()),
(Transaction, (8554, 10, datetime.datetime(2013, 6, 19), 100, "0000")),
(VolumeShareSlippage, ()), (Account, ()), (Portfolio, ()),
(ProtocolPosition, (8554, ))
]
new_case.insert(0, key)
results.append(new_case)
return results
sim_params_daily = SimulationParameters(
datetime.datetime(2013, 6, 19, tzinfo=pytz.UTC),
datetime.datetime(2013, 6, 19, tzinfo=pytz.UTC),
10000,
emission_rate='daily')
sim_params_minute = SimulationParameters(
datetime.datetime(2013, 6, 19, tzinfo=pytz.UTC),
datetime.datetime(2013, 6, 19, tzinfo=pytz.UTC),
10000,
emission_rate='minute')
returns = factory.create_returns_from_list(
[1.0], sim_params_daily)
def object_serialization_cases(skip_daily=False):
# Wrapped in a function to recreate DI objects.
cases = [
(Blotter, (), {}, 'repr'),
(Order, (datetime.datetime(2013, 6, 19), 8554, 100), {}, 'dict'),
(PerShare, (), {}, 'dict'),
(PerTrade, (), {}, 'dict'),
(PerDollar, (), {}, 'dict'),
(PerformancePeriod,
(10000,), {'position_tracker': PositionTracker()}, 'to_dict'),
(Position, (8554,), {}, 'dict'),
(PositionTracker, (), {}, 'dict'),
(PerformanceTracker, (sim_params_minute,), {}, 'to_dict'),
