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 get_test_object_futures():
"""
Returns some standard test data
"""
data = csvFuturesSimData(datapath_dict=dict(config_data = "sysdata.tests.configtestdata", adjusted_prices = "sysdata.tests.multiplepricestestdata", spot_fx_data = "sysdata.tests.fxtestdata", multiple_price_data = "sysdata.tests.multiplepricestestdata"))
config = Config("systems.provided.example.exampleconfig.yaml")
rawdata = FuturesRawData()
return (rawdata, data, config)
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.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)
: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 = csvFuturesSimData()
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 get_test_object_futures_with_rules_and_capping():
"""
Returns some standard test data
"""
data = csvFuturesSimData(datapath_dict=dict(config_data = "sysdata.tests.configtestdata", adjusted_prices = "sysdata.tests.adjtestdata", spot_fx_data = "sysdata.tests.fxtestdata", multiple_price_data = "sysdata.tests.multiplepricestestdata"))
rawdata = FuturesRawData()
rules = Rules()
config = Config("systems.provided.example.exampleconfig.yaml")
capobject = ForecastScaleCap()
return (capobject, rules, rawdata, data, config)
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.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)
: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 = csvFuturesSimData()
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 get_test_object_futures():
"""
Returns some standard test data
"""
data = csvFuturesSimData(datapath_dict=dict(
config_data="sysdata.tests.configtestdata",
adjusted_prices="sysdata.tests.multiplepricestestdata",
spot_fx_data="sysdata.tests.fxtestdata",
multiple_price_data="sysdata.tests.multiplepricestestdata"))
config = Config("systems.provided.example.exampleconfig.yaml")
rawdata = FuturesRawData()
return (rawdata, data, config)
def get_test_object_futures_with_pos_sizing_estimates():
"""
Returns some standard test data
"""
data = csvFuturesSimData(datapath_dict=dict(config_data = "sysdata.tests.configtestdata", adjusted_prices = "sysdata.tests.adjtestdata", spot_fx_data = "sysdata.tests.fxtestdata", multiple_price_data = "sysdata.tests.multiplepricestestdata"))
rawdata = FuturesRawData()
rules = Rules()
config = Config("systems.provided.example.estimateexampleconfig.yaml")
capobject = ForecastScaleCap()
combobject = ForecastCombine()
posobject = PositionSizing()
account = Account()
return (account, posobject, combobject, capobject, rules, rawdata, data,
config)
def get_test_object_futures_with_rules_and_capping():
"""
Returns some standard test data
"""
data = csvFuturesSimData(datapath_dict=dict(
config_data="sysdata.tests.configtestdata",
adjusted_prices="sysdata.tests.adjtestdata",
spot_fx_data="sysdata.tests.fxtestdata",
multiple_price_data="sysdata.tests.multiplepricestestdata"))
rawdata = FuturesRawData()
rules = Rules()
config = Config("systems.provided.example.exampleconfig.yaml")
capobject = ForecastScaleCap()
return (capobject, rules, rawdata, data, config)
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(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 get_test_object_futures_with_pos_sizing_estimates():
"""
Returns some standard test data
"""
data = csvFuturesSimData(datapath_dict=dict(
config_data="sysdata.tests.configtestdata",
adjusted_prices="sysdata.tests.adjtestdata",
spot_fx_data="sysdata.tests.fxtestdata",
multiple_price_data="sysdata.tests.multiplepricestestdata"))
rawdata = FuturesRawData()
rules = Rules()
config = Config("systems.provided.example.estimateexampleconfig.yaml")
capobject = ForecastScaleCap()
combobject = ForecastCombine()
posobject = PositionSizing()
account = Account()
return (account, posobject, combobject, capobject, rules, rawdata, data,
config)
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
"""
Get some data to test the handcrafting method
"""
from sysdata.csv.csv_sim_futures_data import csvFuturesSimData
from syscore.handcrafting import Portfolio
import pandas as pd
data = csvFuturesSimData()
code_list = [
'BOBL', 'BUND', 'US10', 'US20', 'KR3', 'KR10', 'EDOLLAR', 'CORN',
'CRUDE_W', 'GAS_US'
]
def calc_weekly_return(instrument_code, start_date=pd.datetime(2014, 1, 1)):
price = data[instrument_code]
price = price[start_date:]
weekly_price = price.resample("W").last()
denom_price = data.get_instrument_raw_carry_data(instrument_code).PRICE
denom_weekly_price = denom_price.resample("W").last()
weekly_returns = (weekly_price -
weekly_price.shift(1)) / denom_weekly_price
return weekly_returns[start_date:]
returns = dict([(instrument_code, calc_weekly_return(instrument_code))
for instrument_code in code_list])
returns = pd.DataFrame(returns)
from sysdata.csv.csv_sim_futures_data import csvFuturesSimData
from sysobjects.roll_calendars import rollCalendar
from sysdata.csv.csv_roll_calendars import csvRollCalendarData
from sysdata.mongodb.mongo_roll_data import mongoRollParametersData
"""
Generate the roll calendars from existing data
"""
if __name__ == "__main__":
csv_roll_calendars = csvRollCalendarData()
sim_futures_data = csvFuturesSimData()
mongo_rollparameters = mongoRollParametersData()
instrument_list = sim_futures_data.get_instrument_list()
for instrument_code in instrument_list:
print(instrument_code)
multiple_prices = sim_futures_data.get_all_multiple_prices(
instrument_code)
roll_parameters = mongo_rollparameters.get_roll_parameters(
instrument_code)
roll_calendar = rollCalendar.back_out_from_multiple_prices(
multiple_prices)
print("Calendar:")
print(roll_calendar)
# We ignore duplicates since this is run regularly
csv_roll_calendars.add_roll_calendar(instrument_code,
roll_calendar,
ignore_duplication=True)
Work up a minimum example of a trend following system
"""
# Get some data
from sysdata.csv.csv_sim_futures_data import csvFuturesSimData
""""
Let's get some data
We can get data from various places; however for now we're going to use
prepackaged 'legacy' data stored in csv files
"""
data = csvFuturesSimData()
print(data)
"""
We get stuff out of data with methods
"""
print(data.get_instrument_list())
print(data.get_raw_price("EDOLLAR").tail(5))
"""
data can also behave in a dict like manner (though it's not a dict)
"""
print(data['SP500'])
print(data.keys())
"""
from sysdata.csv.csv_sim_futures_data import csvFuturesSimData
from sysdata.futures.roll_calendars import rollCalendar
from sysdata.csv.csv_roll_calendars import csvRollCalendarData
from sysdata.mongodb.mongo_roll_data import mongoRollParametersData
"""
Generate the roll calendars from existing data
"""
if __name__ == '__main__':
csv_roll_calendars = csvRollCalendarData()
sim_futures_data = csvFuturesSimData()
mongo_rollparameters = mongoRollParametersData()
instrument_list = sim_futures_data.get_instrument_list()
for instrument_code in instrument_list:
print(instrument_code)
current_and_forward_data = sim_futures_data.get_current_and_forward_price_data(instrument_code)
roll_parameters = mongo_rollparameters.get_roll_parameters(instrument_code)
roll_calendar = rollCalendar.back_out_from_current_and_forward_data(current_and_forward_data, roll_parameters)
print("Calendar:")
print(roll_calendar)
## We ignore duplicates since this is run regularly
csv_roll_calendars.add_roll_calendar(roll_calendar, instrument_code, ignore_duplication=True)
