def test_get_capped_forecast(self):
# fixed, normal cap
self.assertAlmostEqual(
self.system.forecastScaleCap.get_capped_forecast(
"EDOLLAR", "ewmac8").tail(1).values[0], 0.871230635)
# estimated, normal cap
config = copy.copy(self.config)
config.use_forecast_scale_estimates = True
system2 = System([self.rawdata, self.rules,
self.forecast_scale_cap()], self.data, config)
self.assertAlmostEqual(system2.forecastScaleCap.get_forecast_scalar(
"EDOLLAR", "ewmac8").tail(1).values[0],
5.8,
places=1)
# binding cap
config.use_forecast_scale_estimates = False
config.forecast_cap = 0.2
system3 = System([self.rawdata, self.rules,
self.forecast_scale_cap()], self.data, config)
self.assertAlmostEqual(
system3.forecastScaleCap.get_capped_forecast(
"EDOLLAR", "ewmac8").tail(1).values[0], 0.2)
def test_get_forecast_scalar(self):
# fixed
## From config
self.assertEqual(self.system.forecastScaleCap.get_forecast_scalar("EDOLLAR", "ewmac8"), 5.3)
## default
config = copy.copy(self.config)
unused = config.trading_rules['ewmac8'].pop('forecast_scalar')
system2 = System([self.rawdata, self.rules, self.forecast_scale_cap()], self.data, config)
self.assertEqual(system2.forecastScaleCap.get_forecast_scalar("EDOLLAR", "ewmac8"), 1.0)
## other config location
setattr(config, 'forecast_scalars', dict(ewmac8=11.0))
system3 = System([self.rawdata, self.rules, self.forecast_scale_cap()], self.data, config)
self.assertEqual(system3.forecastScaleCap.get_forecast_scalar("EDOLLAR", "ewmac8"), 11.0)
# estimated
config = copy.copy(self.config)
config.use_forecast_scale_estimates = True
system2 = System([self.rawdata, self.rules, self.forecast_scale_cap()], self.data, config)
## From default
self.assertAlmostEqual(system2.forecastScaleCap.get_forecast_scalar("EDOLLAR", "ewmac8").tail(1).values[0], 5.85109081)
## From config
scale_config=dict(pool_instruments=False)
config.forecast_scalar_estimate=scale_config
system2=System([self.rawdata, self.rules, self.forecast_scale_cap()], self.data, config)
self.assertAlmostEqual(system2.forecastScaleCap.get_forecast_scalar("EDOLLAR", "ewmac8").tail(1).values[0], 5.653444301)
def simplesystem(data=None, config=None, log_level="on"):
"""
Example of how to 'wrap' a complete system
"""
if config is None:
config = Config("systems.provided.example.simplesystemconfig.yaml")
if data is None:
data = csvFuturesSimData()
my_system = System(
[
Account(),
Portfolios(),
PositionSizing(),
ForecastCombine(),
ForecastScaleCap(),
Rules(),
],
data,
config,
)
my_system.set_logging_level(log_level)
return my_system
def futures_system(sim_data=arg_not_supplied,
config_filename="systems.provided.rob_system.config.yaml"):
if sim_data is arg_not_supplied:
sim_data = dbFuturesSimData()
config = Config(config_filename)
system = System(
[
Risk(),
accountForOptimisedStage(),
optimisedPositions(),
Portfolios(),
PositionSizing(),
myFuturesRawData(),
ForecastCombine(),
volAttenForecastScaleCap(),
Rules(),
],
sim_data,
config,
)
system.set_logging_level("on")
return system
def testRules(self):
# config=Config(dict(trading_rules=dict(ewmac=dict(function="systems.provided.example.rules.ewmac_forecast_with_defaults"))))
NOTUSEDrawdata, data, NOTUSEDconfig = get_test_object()
rules = Rules(
dict(
function=
"systems.provided.example.rules.ewmac_forecast_with_defaults"))
system = System([rules], data)
ans = system.rules.get_raw_forecast("EDOLLAR", "rule0")
self.assertAlmostEqual(ans.tail(1).values[0], -3.280028, 5)
config = Config(
dict(trading_rules=dict(ewmac=dict(
function=
"systems.provided.example.rules.ewmac_forecast_with_defaults"))
))
rules = Rules()
system = System([rules], data, config)
ans = system.rules.get_raw_forecast("EDOLLAR", "ewmac")
self.assertAlmostEqual(ans.tail(1).values[0], -3.28002839, 5)
config = Config("systems.provided.example.exampleconfig.yaml")
rawdata = RawData()
rules = Rules()
system = System([rules, rawdata], data, config)
ans = system.rules.get_raw_forecast("EDOLLAR", "ewmac8")
self.assertAlmostEqual(ans.tail(1).values[0], -2.158634, 5)
def futures_system(data=None, config=None, trading_rules=None, log_level="terse"):
"""
:param data: data object (defaults to reading from csv files)
:type data: sysdata.data.Data, or anything that inherits from it
:param config: Configuration object (defaults to futuresconfig.yaml in this directory)
:type config: sysdata.configdata.Config
:param trading_rules: Set of trading rules to use (defaults to set specified in config object)
:param trading_rules: list or dict of TradingRules, or something that can be parsed to that
:param log_level: Set of trading rules to use (defaults to set specified in config object)
:type log_level: str
"""
if data is None:
data = csvFuturesData()
if config is None:
config = Config(
"systems.provided.futures_chapter15.futuresestimateconfig.yaml")
rules = Rules(trading_rules)
system = System([Account(), Portfolios(), PositionSizing(), FuturesRawData(), ForecastCombine(),
ForecastScaleCap(), rules], data, config)
system.set_logging_level(log_level)
return system
def testRules(self):
# config=Config(dict(trading_rules=dict(ewmac=dict(function="systems.provided.example.rules.ewmac_forecast_with_defaults"))))
data = csvFuturesData("sysdata.tests")
rules = Rules(
dict(
function=
"systems.provided.example.rules.ewmac_forecast_with_defaults"))
system = System([rules], data)
ans = system.rules.get_raw_forecast("EDOLLAR", "rule0")
self.assertAlmostEqual(ans.tail(1).values[0], 2.1384223788141838, 5)
config = Config(
dict(trading_rules=dict(ewmac=dict(
function=
"systems.provided.example.rules.ewmac_forecast_with_defaults"))
))
rules = Rules()
system = System([rules], data, config)
ans = system.rules.get_raw_forecast("EDOLLAR", "ewmac")
self.assertAlmostEqual(ans.tail(1).values[0], 2.1384223788141838, 5)
config = Config("systems.provided.example.exampleconfig.yaml")
rawdata = RawData()
rules = Rules()
system = System([rules, rawdata], data, config)
ans = system.rules.get_raw_forecast("EDOLLAR", "ewmac8")
self.assertAlmostEqual(ans.tail(1).values[0], 0.16438313875, 5)
def test_get_raw_fixed_forecast_weights(self):
# fixed weights:
# nested dict (in config)
ans1a = self.system.combForecast.get_forecast_weights("EDOLLAR")
self.assertAlmostEqual(ans1a.ewmac16.values[-1], 0.5)
ans1b = self.system.combForecast.get_raw_forecast_weights("BUND")
self.assertEqual(ans1b.ewmac8.values[-1], 1.0)
# missing; equal weights
config = copy.copy(self.config)
del (config.forecast_weights)
system2 = System(
[self.rawdata, self.rules, self.fcs,
self.forecast_combine()], self.data, config)
ans2 = system2.combForecast.get_forecast_weights("BUND")
self.assertAlmostEqual(ans2.ewmac8.values[-1], 0.49917057) # smoothing
# non nested dict
config.forecast_weights = dict(ewmac8=0.1, ewmac16=0.9)
system3 = System(
[self.rawdata, self.rules, self.fcs,
self.forecast_combine()], self.data, config)
ans3 = system3.combForecast.get_forecast_weights("BUND")
self.assertEqual(ans3.ewmac8.values[-1], 0.099834114877206212)
def test_get_trading_rule_list(self):
# fixed weights
ans = self.system.combForecast.get_trading_rule_list("EDOLLAR")
self.assertEqual(ans, ['ewmac16', 'ewmac8'])
ans2 = self.system.combForecast.get_trading_rule_list("BUND")
self.assertEqual(ans2, ['ewmac8'])
# fixed weights - non nested dict
config = copy.copy(self.config)
config.forecast_weights = dict(ewmac8=.5, ewmac16=.5)
system2 = System(
[self.rawdata, self.rules, self.fcs,
self.forecast_combine()], self.data, config)
ans3 = system2.combForecast.get_trading_rule_list("EDOLLAR")
self.assertEqual(ans3, ['ewmac16', 'ewmac8'])
ans4 = system2.combForecast.get_trading_rule_list("BUND")
self.assertEqual(ans4, ans3)
# fixed weights - missing
del (config.forecast_weights)
system3 = System(
[self.rawdata, self.rules, self.fcs,
self.forecast_combine()], self.data, config)
ans5 = system3.combForecast.get_trading_rule_list("EDOLLAR")
self.assertEqual(ans5, ['ewmac16', 'ewmac8'])
# estimated weights - missing
config.use_forecast_weight_estimates = True
system4 = System(
[self.rawdata, self.rules, self.fcs,
self.forecast_combine()], self.data, config)
ans6 = system4.combForecast.get_trading_rule_list("EDOLLAR")
self.assertEqual(ans6, ['ewmac16', 'ewmac8'])
# estimated weights - non nested
setattr(config, "rule_variations", ["ewmac8"])
system5 = System(
[self.rawdata, self.rules, self.fcs,
self.forecast_combine()], self.data, config)
ans6 = system5.combForecast.get_trading_rule_list("EDOLLAR")
self.assertEqual(ans6, ['ewmac8'])
#estimated weights - nested dict
setattr(
config, "rule_variations",
dict(EDOLLAR=["ewmac8"],
BUND=["ewmac16"],
US10=["ewmac8", "ewmac16"]))
system6 = System(
[self.rawdata, self.rules, self.fcs,
self.forecast_combine()], self.data, config)
ans7 = system6.combForecast.get_trading_rule_list("EDOLLAR")
self.assertEqual(ans7, ['ewmac8'])
ans8 = system6.combForecast.get_trading_rule_list("BUND")
self.assertEqual(ans8, ['ewmac16'])
ans8 = system6.combForecast.get_trading_rule_list("US10")
self.assertEqual(ans8, ['ewmac16', 'ewmac8']) # missing
def random_system_for_regression(config, rules, log_level="on"):
my_system = System([Account(), PortfoliosFixed(), PositionSizing(), ForecastCombineEstimated(), ForecastScaleCapEstimated(), rules,
RawData()], csvFuturesData(), config)
my_system.set_logging_level(log_level)
return my_system
def futures_system(data=None, config=None, trading_rules=None, log_level="on"):
"""
:param data: data object (defaults to reading from csv files)
:type data: sysdata.data.Data, or anything that inherits from it
:param config: Configuration object (defaults to futuresconfig.yaml in this directory)
:type config: sysdata.configdata.Config
:param trading_rules: Set of trading rules to use (defaults to set specified in config object)
:type trading_rules: list or dict of TradingRules, or something that can be parsed to that
:param log_level: How much logging to do
:type log_level: str
>>> system=futures_system(log_level="off")
>>> system
System with stages: accounts, portfolio, positionSize, rawdata, combForecast, forecastScaleCap, rules
>>> system.rules.get_raw_forecast("EDOLLAR", "ewmac2_8").dropna().head(2)
ewmac2_8
1983-10-10 0.695929
1983-10-11 -0.604704
ewmac2_8
2015-04-21 0.172416
2015-04-22 -0.477559
>>> system.rules.get_raw_forecast("EDOLLAR", "carry").dropna().head(2)
carry
1983-10-10 0.952297
1983-10-11 0.854075
carry
2015-04-21 0.350892
2015-04-22 0.350892
"""
if data is None:
data = csvFuturesData()
if config is None:
config = Config(
"systems.provided.futures_chapter15.futuresconfig.yaml")
rules = Rules(trading_rules)
system = System([
Account(),
PortfoliosFixed(),
PositionSizing(),
FuturesRawData(),
ForecastCombine(),
ForecastScaleCap(), rules
], data, config)
system.set_logging_level(log_level)
return system
def futures_system(data=None, config=None, trading_rules=None, log_level="on"):
"""
:param data: data object (defaults to reading from csv files)
:type data: sysdata.data.Data, or anything that inherits from it
:param config: Configuration object (defaults to futuresconfig.yaml in this directory)
:type config: sysdata.configdata.Config
:param trading_rules: Set of trading rules to use (defaults to set specified in config object)
:type trading_rules: list or dict of TradingRules, or something that can be parsed to that
:param log_level: How much logging to do
:type log_level: str
>>> system=futures_system(log_level="off")
>>> system
System with stages: accounts, portfolio, positionSize, rawdata, combForecast, forecastScaleCap, rules
>>> system.rules.get_raw_forecast("EDOLLAR", "ewmac2_8").dropna().head(2)
ewmac2_8
1983-10-10 0.695929
1983-10-11 -0.604704
ewmac2_8
2015-04-21 0.172416
2015-04-22 -0.477559
>>> system.rules.get_raw_forecast("EDOLLAR", "carry").dropna().head(2)
carry
1983-10-10 0.952297
1983-10-11 0.854075
carry
2015-04-21 0.350892
2015-04-22 0.350892
"""
if data is None:
data = csvFuturesData()
if config is None:
config = Config(
"systems.provided.futures_chapter15.futuresconfig.yaml")
rules = Rules(trading_rules)
system = System([
Account(), Portfolios(), PositionSizing(), FuturesRawData(),
ForecastCombine(), ForecastScaleCap(), rules
], data, config)
system.set_logging_level(log_level)
return system
def random_system_for_regression(data, config, rules, log_level="on"):
my_system = System([
Account(), PortfoliosFixed(), PositionSizing(),
ForecastCombineEstimated(), ForecastScaleCapEstimated(), rules,
RawData()
], data, config)
my_system.set_logging_level(log_level)
return my_system
def simplesystem(data=None, config=None, log_level="on"):
"""
Example of how to 'wrap' a complete system
"""
if config is None:
config = Config("systems.provided.example.simplesystemconfig.yaml")
if data is None:
data = csvFuturesData()
my_system = System([Account(), PortfoliosFixed(), PositionSizing(), ForecastCombineFixed(), ForecastScaleCapFixed(), Rules()
], data, config)
my_system.set_logging_level(log_level)
return my_system
def test_simple_system_config_import(self, data):
my_config = Config("systems.provided.example.simplesystemconfig.yaml")
my_config.risk_overlay = arg_not_supplied
my_config.exclude_instrument_lists = dict(
ignore_instruments=["MILK"],
trading_restrictions=["BUTTER"],
bad_markets=["CHEESE"],
)
print(my_config)
my_system = System(
[
Account(),
Portfolios(),
PositionSizing(),
ForecastCombine(),
ForecastScaleCap(),
Rules(),
RawData(),
],
data,
my_config,
)
print(my_system.rules.get_raw_forecast("EDOLLAR", "ewmac32").tail(5))
print(my_system.rules.get_raw_forecast("EDOLLAR", "ewmac8").tail(5))
print(
my_system.forecastScaleCap.get_capped_forecast("EDOLLAR", "ewmac32").tail(5)
)
print(my_system.forecastScaleCap.get_forecast_scalar("EDOLLAR", "ewmac32"))
print(my_system.combForecast.get_combined_forecast("EDOLLAR").tail(5))
print(my_system.combForecast.get_forecast_weights("EDOLLAR").tail(5))
print(my_system.positionSize.get_subsystem_position("EDOLLAR").tail(5))
print(my_system.portfolio.get_notional_position("EDOLLAR").tail(5))
def testCallingTradingRule(self):
# config=Config(dict(trading_rules=dict(ewmac=dict(function="systems.provided.example.rules.ewmac_forecast_with_defaults"))))
data = csvFuturesData("sysdata.tests")
rawdata = RawData()
rules = Rules()
system = System([rawdata, rules], data)
# Call with default data and config
rule = TradingRule(ewmac_forecast_with_defaults)
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.tail(1).values[0], 2.1384223788141838, 5)
# Change the data source
rule = TradingRule((
"systems.provided.example.rules.ewmac_forecast_with_defaults_no_vol",
["rawdata.get_daily_prices",
"rawdata.daily_returns_volatility"], dict()))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.tail(1).values[0], 0.029376, 5)
rule = TradingRule(
dict(
function=
"systems.provided.example.rules.ewmac_forecast_with_defaults_no_vol",
data=[
"rawdata.get_daily_prices",
"rawdata.daily_returns_volatility"
],
other_args=dict(Lfast=50, Lslow=200)))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.tail(1).values[0], 3.84426755)
def testCallingTradingRule(self):
# config=Config(dict(trading_rules=dict(ewmac=dict(function="systems.provided.example.rules.ewmac_forecast_with_defaults"))))
NOTUSEDrawdata, data, NOTUSEDconfig = get_test_object()
rawdata = RawData()
rules = Rules()
system = System([rawdata, rules], data)
# Call with default data and config
rule = TradingRule(ewmac_forecast_with_defaults)
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.tail(1).values[0], -3.280028, 5)
# Change the data source
rule = TradingRule((
"systems.provided.example.rules.ewmac_forecast_with_defaults_no_vol",
["rawdata.get_daily_prices",
"rawdata.daily_returns_volatility"], dict()))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.tail(1).values[0], -1.24349, 5)
rule = TradingRule(
dict(
function=
"systems.provided.example.rules.ewmac_forecast_with_defaults_no_vol",
data=[
"rawdata.get_daily_prices",
"rawdata.daily_returns_volatility"
],
other_args=dict(Lfast=50, Lslow=200)))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.tail(1).values[0], -3.025001057146)
def test_simple_system_costs(
self,
data,
raw_data,
my_rules,
my_config,
fcs,
combiner,
possizer,
portfolio,
account,
):
my_config.forecast_weights = dict(ewmac8=0.5, ewmac32=0.5)
my_config.instrument_weights = dict(US10=0.1, EDOLLAR=0.4, CORN=0.3, SP500=0.2)
my_system = System(
[fcs, my_rules, combiner, possizer, portfolio, account, raw_data],
data,
my_config,
)
profits = my_system.accounts.portfolio()
print(profits.percent.stats())
# have costs data now
print(profits.gross.percent.stats())
print(profits.net.percent.stats())
def setUp(self):
stage = SystemStage()
stage.name = "test"
data = simData()
config = Config(dict(instruments=["another_code", "code"]))
system = System([stage], data=data, config=config)
self.system = system
def setUp(self):
(accounts, fcs, rules, rawdata, data,
config) = get_test_object_futures_with_rules_and_capping_estimate()
system = System(
[accounts, rawdata, rules, fcs,
ForecastCombineEstimated()], data, config)
setattr(self, "system", system)
def test_get_daily_cash_vol_target(self):
ans_dict = self.system.positionSize.get_vol_target_dict()
self.assertEqual(ans_dict["base_currency"], "GBP")
self.assertEqual(ans_dict["annual_cash_vol_target"], 16000.0)
self.assertEqual(ans_dict["daily_cash_vol_target"], 1000.0)
self.assertEqual(ans_dict["notional_trading_capital"], 100000.0)
self.assertEqual(ans_dict["percentage_vol_target"], 16.0)
# test for missing config defaults
system2 = System(
[
self.rawdata,
self.rules,
self.fcs,
self.forecast_combine,
self.position_sizing(),
],
self.data,
)
ans_dict2 = system2.positionSize.get_vol_target_dict()
self.assertEqual(ans_dict2["base_currency"], "USD")
self.assertEqual(ans_dict2["annual_cash_vol_target"], 160000.0)
self.assertEqual(ans_dict2["daily_cash_vol_target"], 10000.0)
self.assertEqual(ans_dict2["notional_trading_capital"], 1000000.0)
self.assertEqual(ans_dict2["percentage_vol_target"], 16.0)
def updated_buffered_positions(data: dataBlob, strategy_name: str,
system: System):
log = data.log
data_optimal_positions = dataOptimalPositions(data)
list_of_instruments = system.get_instrument_list()
for instrument_code in list_of_instruments:
lower_buffer, upper_buffer = get_position_buffers_from_system(
system, instrument_code)
position_entry = construct_position_entry(
data=data,
system=system,
instrument_code=instrument_code,
lower_buffer=lower_buffer,
upper_buffer=upper_buffer,
)
instrument_strategy = instrumentStrategy(
instrument_code=instrument_code, strategy_name=strategy_name)
data_optimal_positions.update_optimal_position_for_instrument_strategy(
instrument_strategy=instrument_strategy,
position_entry=position_entry)
log.msg(
"New buffered positions %.3f %.3f" %
(position_entry.lower_position, position_entry.upper_position),
instrument_code=instrument_code,
)
def setUp(self):
(
posobject,
combobject,
capobject,
rules,
rawdata,
data,
config,
) = get_test_object_futures_with_pos_sizing()
system = System(
[rawdata, rules, posobject, combobject, capobject, Portfolios()],
data,
config,
)
self.system = system
self.config = config
self.rules = rules
self.rawdata = rawdata
self.fcs = capobject
self.forecast_combine = combobject
self.data = data
self.possizing = posobject
self.portfolios = Portfolios
def test_estimated_dm(self):
config = copy.copy(self.config)
config.use_instrument_weight_estimates = True
system2 = System(
[
self.rawdata,
self.rules,
self.possizing,
self.forecast_combine,
self.fcs,
Account(),
self.portfolios(),
],
self.data,
config,
)
ans = system2.portfolio.get_instrument_correlation_matrix(
).corr_list[-1]
self.assertAlmostEqual(ans[0][1], 0.3889, places=3)
self.assertAlmostEqual(ans[0][2], 0.5014, places=3)
self.assertAlmostEqual(ans[1][2], 0.8771, places=3)
ans = system2.portfolio.get_estimated_instrument_diversification_multiplier(
)
self.assertAlmostEqual(ans.values[-1], 1.1855, places=3)
def setUp(self):
system = System(
[testStage1(), testStage2()],
Data(),
Config(dict(instruments=["code", "another_code"])))
self.system = system
def futures_system(
data=None,
config=None,
trading_rules=None,
log_level="terse"):
"""
:param data: data object (defaults to reading from csv files)
:type data: sysdata.data.simData, or anything that inherits from it
:param config: Configuration object (defaults to futuresconfig.yaml in this directory)
:type config: sysdata.configdata.Config
:param trading_rules: Set of trading rules to use (defaults to set specified in config object)
:param trading_rules: list or dict of TradingRules, or something that can be parsed to that
:param log_level: Set of trading rules to use (defaults to set specified in config object)
:type log_level: str
"""
if data is None:
data = csvFuturesSimData()
if config is None:
config = Config(
"systems.provided.futures_chapter15.futuresestimateconfig.yaml")
rules = Rules(trading_rules)
system = System(
[
Account(),
Portfolios(),
PositionSizing(),
FuturesRawData(),
ForecastCombine(),
ForecastScaleCap(),
rules,
],
data,
config,
)
system.set_logging_level(log_level)
return system
def setUp(self):
(rules, rawdata, data, config) = get_test_object_futures_with_rules()
system = System([rawdata, rules, ForecastScaleCap()], data, config)
self.system = system
self.config = config
self.rules = rules
self.rawdata = rawdata
self.forecast_scale_cap = ForecastScaleCap
self.data = data
def test_simple_system_trading_rule(self, data, raw_data, ewmac_8, ewmac_32):
ewmac_rule = TradingRule(ewmac)
print(ewmac_rule)
my_rules = Rules(dict(ewmac8=ewmac_8, ewmac32=ewmac_32))
print(my_rules.trading_rules()["ewmac32"])
my_system = System([my_rules, raw_data], data)
my_system.rules.get_raw_forecast("EDOLLAR", "ewmac32").tail(5)
def testCarryRule(self):
NOTUSEDrawdata, data, NOTUSEDconfig = get_test_object()
rawdata = FuturesRawData()
rules = Rules()
system = System([rawdata, rules], data)
rule = TradingRule(carry2, [
"rawdata.daily_annualised_roll",
], dict(smooth_days=90))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.tail(1).values[0], 0.138302, 5)
def test_get_forecast_cap(self):
ans=self.system.forecastScaleCap.get_forecast_cap()
self.assertEqual(ans, 21.0)
## test defaults
config = self.config
del(config.forecast_cap)
system3=System([self.rawdata, self.rules, self.forecast_scale_cap()], self.data, config)
ans=system3.forecastScaleCap.get_forecast_cap()
self.assertEqual(ans, 20.0)
def setUpWithEstimatedReturns(self):
config = copy.copy(self.config)
config.use_forecast_weight_estimates = True
config.use_forecast_div_mult_estimates = True
new_system = System([
self.rawdata, self.rules, self.fcs,
self.forecast_combine(),
Account()
], self.data, config)
return new_system
def testCarryRule(self):
data = csvFuturesData("sysdata.tests")
rawdata = FuturesRawData()
rules = Rules()
system = System([rawdata, rules], data)
rule = TradingRule(carry, [
"rawdata.daily_annualised_roll", "rawdata.daily_returns_volatility"
], dict(smooth_days=90))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.iloc[-1][0], 0.411686026, 5)
def futures_system(data, config):
system = System(
[
Risk(),
accountForOptimisedStage(),
optimisedPositions(),
Portfolios(),
PositionSizing(),
RawData(),
ForecastCombine(),
ForecastScaleCap(),
Rules(),
],
data,
config,
)
system.set_logging_level("on")
return system
def setUp(self):
class testStage(SystemStage):
@property
def name(self):
return "test"
stage = testStage()
data = simData()
config = Config(dict(instruments=["another_code", "code"]))
system = System([stage], data=data, config=config)
self.system = system
from syscore.accounting import *
from systems.basesystem import System
from systems.account import Account
from systems.tests.testdata import get_test_object_futures_with_portfolios
(portfolio, posobject, combobject, capobject, rules, rawdata, data, config)=get_test_object_futures_with_portfolios()
system=System([portfolio, posobject, combobject, capobject, rules, rawdata, Account()], data, config)
instrument_code="EDOLLAR"
rule_variations=system.rules.trading_rules()
rule_variation_name="ewmac16"
this_stage=system.accounts
price = this_stage.get_daily_price(instrument_code)
get_daily_returns_volatility = this_stage.get_daily_returns_volatility(
instrument_code)
forecast = this_stage.get_capped_forecast(
instrument_code, rule_variation_name)
accountCurve(percentage=True, price=price, forecast=forecast, get_daily_returns_volatility=get_daily_returns_volatility)
instruments=system.get_instrument_list()
capital = this_stage.get_notional_capital()
ann_risk_target=system.positionSize.get_daily_cash_vol_target()['percentage_vol_target']/100.0
acc_list=[]
def testName(self):
stage = SystemStage()
stage.name = "test"
data=Data()
stage._protected = ["protected"]
system = System([stage], data, None)
print(system._cache)
system.set_item_in_cache(3, ("test","a"), "US10")
print(system._cache)
self.assertEqual(system.get_item_from_cache(("test","a"), "US10"), 3)
def afunction(system, instrument_code, stage, wibble, another_wibble=10):
return instrument_code + wibble + str(another_wibble) + stage.name
def anestedfunction(system, instrument_code,
keyname, stage, wibble, another_wibble=10):
return instrument_code + wibble + keyname + str(another_wibble) + stage.name
ans = system.calc_or_cache("b", "c", afunction, stage, "d")
print(system._cache)
ans = system.calc_or_cache("b", "c", afunction, stage, "d", 20.0)
print(system._cache)
ans = system.calc_or_cache_nested(
"c", "SP500", "thing", anestedfunction, stage, "k")
print(system._cache)
ans = system.calc_or_cache("b", ALL_KEYNAME, afunction, stage, "e", 120.0)
print(system._cache)
ans = system.calc_or_cache(
"protected", ALL_KEYNAME, afunction, stage, "e", 120.0)
ans = system.get_item_from_cache(("test""c"), "SP500", "thing")
print(system._cache)
system._delete_item_from_cache(("test","b"), "c")
print(system._cache)
ans = system.set_item_in_cache(10.0, ("test", "protected"), "SP500")
print(system._cache)
print(system.get_item_from_cache(("test","b"), ALL_KEYNAME))
ans = system.set_item_in_cache( "protected", ("test2",10.0), "SP500")
print(system._cache)
print(system.get_items_across_system())
print(system.get_items_with_data())
print(system.get_protected_items())
print(system.get_items_for_instrument("SP500"))
print(system.get_itemnames_for_stage("test"))
system.delete_items_for_stage("test2")
print(system._cache)
system.delete_items_across_system()
print(system._cache)
system.delete_items_across_system(True)
print(system._cache)
system.delete_items_for_instrument("SP500")
print(system._cache)
system.delete_items_for_instrument("SP500", True)
print(system._cache)
system.delete_item(("test","a"))
print(system._cache)
from systems.forecasting import Rules
"""
We can create rules in a number of different ways
Note that to make our rule work it needs to have
"""
my_rules = Rules(ewmac)
print(my_rules.trading_rules())
my_rules = Rules(dict(ewmac=ewmac))
print(my_rules.trading_rules())
from systems.basesystem import System
my_system = System([my_rules], data)
print(my_system)
print(my_system.rules.get_raw_forecast("EDOLLAR", "ewmac").tail(5))
"""
Define a TradingRule
"""
from systems.forecasting import TradingRule
ewmac_rule = TradingRule(ewmac)
my_rules = Rules(dict(ewmac=ewmac_rule))
ewmac_rule
