class StrategyFXCTA_Example(StrategyTemplate):
def __init__(self):
super(StrategyTemplate, self).__init__()
self.logger = LoggerManager().getLogger(__name__)
##### FILL IN WITH YOUR OWN PARAMETERS FOR display, dumping, TSF etc.
self.tsfactory = LightTimeSeriesFactory()
self.DUMP_CSV = 'output_data/'
self.DUMP_PATH = 'output_data/' + datetime.date.today().strftime("%Y%m%d") + ' '
self.FINAL_STRATEGY = 'Thalesians FX CTA'
self.SCALE_FACTOR = 3
return
###### Parameters and signal generations (need to be customised for every model)
def fill_backtest_request(self):
##### FILL IN WITH YOUR OWN BACKTESTING PARAMETERS
br = BacktestRequest()
# get all asset data
br.start_date = "04 Jan 1989"
br.finish_date = datetime.datetime.utcnow()
br.spot_tc_bp = 0.5
br.ann_factor = 252
br.plot_start = "01 Apr 2015"
br.calc_stats = True
br.write_csv = False
br.plot_interim = True
br.include_benchmark = True
# have vol target for each signal
br.signal_vol_adjust = True
br.signal_vol_target = 0.1
br.signal_vol_max_leverage = 5
br.signal_vol_periods = 20
br.signal_vol_obs_in_year = 252
br.signal_vol_rebalance_freq = 'BM'
br.signal_vol_resample_freq = None
# have vol target for portfolio
br.portfolio_vol_adjust = True
br.portfolio_vol_target = 0.1
br.portfolio_vol_max_leverage = 5
br.portfolio_vol_periods = 20
br.portfolio_vol_obs_in_year = 252
br.portfolio_vol_rebalance_freq = 'BM'
br.portfolio_vol_resample_freq = None
# tech params
br.tech_params.sma_period = 200
return br
def fill_assets(self):
##### FILL IN WITH YOUR ASSET DATA
# for FX basket
full_bkt = ['EURUSD', 'USDJPY', 'GBPUSD', 'AUDUSD', 'USDCAD',
'NZDUSD', 'USDCHF', 'USDNOK', 'USDSEK']
basket_dict = {}
for i in range(0, len(full_bkt)):
basket_dict[full_bkt[i]] = [full_bkt[i]]
basket_dict['Thalesians FX CTA'] = full_bkt
br = self.fill_backtest_request()
self.logger.info("Loading asset data...")
vendor_tickers = ['FRED/DEXUSEU', 'FRED/DEXJPUS', 'FRED/DEXUSUK', 'FRED/DEXUSAL', 'FRED/DEXCAUS',
'FRED/DEXUSNZ', 'FRED/DEXSZUS', 'FRED/DEXNOUS', 'FRED/DEXSDUS']
time_series_request = TimeSeriesRequest(
start_date = br.start_date, # start date
finish_date = br.finish_date, # finish date
freq = 'daily', # daily data
data_source = 'quandl', # use Quandl as data source
tickers = full_bkt, # ticker (Thalesians)
fields = ['close'], # which fields to download
vendor_tickers = vendor_tickers, # ticker (Quandl)
vendor_fields = ['close'], # which Bloomberg fields to download
cache_algo = 'internet_load_return') # how to return data
asset_df = self.tsfactory.harvest_time_series(time_series_request)
# signalling variables
spot_df = asset_df
spot_df2 = None
return asset_df, spot_df, spot_df2, basket_dict
def construct_signal(self, spot_df, spot_df2, tech_params, br):
##### FILL IN WITH YOUR OWN SIGNALS
# use technical indicator to create signals
# (we could obviously create whatever function we wanted for generating the signal dataframe)
tech_ind = TechIndicator()
tech_ind.create_tech_ind(spot_df, 'SMA', tech_params); signal_df = tech_ind.get_signal()
return signal_df
def construct_strategy_benchmark(self):
###### FILL IN WITH YOUR OWN BENCHMARK
tsr_indices = TimeSeriesRequest(
start_date = '01 Jan 1980', # start date
finish_date = datetime.datetime.utcnow(), # finish date
freq = 'daily', # intraday data
data_source = 'quandl', # use Bloomberg as data source
tickers = ["EURUSD"], # tickers to download
vendor_tickers=['FRED/DEXUSEU'],
fields = ['close'], # which fields to download
vendor_fields = ['close'],
cache_algo = 'cache_algo_return') # how to return data)
df = self.tsfactory.harvest_time_series(tsr_indices)
df.columns = [x.split(".")[0] for x in df.columns]
return df
'GBPUSD',
'AUDUSD'
],
fields=['close'], # which fields to download
vendor_tickers=[
'EURUSD BGN Curncy', # ticker (Bloomberg)
'GBPUSD BGN Curncy',
'AUDUSD BGN Curncy'
],
vendor_fields=['PX_LAST'], # which Bloomberg fields to download
cache_algo='internet_load_return') # how to return data
ltsf = LightTimeSeriesFactory()
df = None
df = ltsf.harvest_time_series(time_series_request)
tsc = TimeSeriesCalcs()
df = tsc.calculate_returns(df)
df = tsc.rolling_corr(df['EURUSD.close'],
20,
data_frame2=df[['GBPUSD.close', 'AUDUSD.close']])
gp = GraphProperties()
gp.title = "1M FX rolling correlations"
gp.scale_factor = 3
pf = PlotFactory()
pf.plot_line_graph(df, adapter='pythalesians', gp=gp)
###### download daily data from Bloomberg for AUD/JPY, NZD/JPY spot with S&P500, then calculate correlation
###### calculate seasonal moves in EUR/USD and GBP/USD (using Quandl data)
if True:
time_series_request = TimeSeriesRequest(
start_date = "01 Jan 1970", # start date
finish_date = datetime.date.today(), # finish date
freq = 'daily', # daily data
data_source = 'quandl', # use Quandl as data source
tickers = ['EURUSD', # ticker (Thalesians)
'GBPUSD'],
fields = ['close'], # which fields to download
vendor_tickers = ['FRED/DEXUSEU', 'FRED/DEXUSUK'], # ticker (Quandl)
vendor_fields = ['close'], # which Bloomberg fields to download
cache_algo = 'internet_load_return') # how to return data
ltsf = LightTimeSeriesFactory()
df = ltsf.harvest_time_series(time_series_request)
df_ret = tsc.calculate_returns(df)
day_of_month_seasonality = seasonality.bus_day_of_month_seasonality(df_ret, partition_by_month = False)
day_of_month_seasonality = tsc.convert_month_day_to_date_time(day_of_month_seasonality)
gp = GraphProperties()
gp.date_formatter = '%b'
gp.title = 'FX spot moves by time of year'
gp.scale_factor = 3
gp.file_output = "output_data/20150724 FX spot seas.png"
pf.plot_line_graph(day_of_month_seasonality, adapter='pythalesians', gp = gp)
if True:
time_series_request = TimeSeriesRequest(
start_date = "01 Jan 2013", # start date
finish_date = datetime.date.today(), # finish date
freq = 'daily', # daily data
data_source = 'google', # use Bloomberg as data source
tickers = ['Apple', 'S&P500 ETF'], # ticker (Thalesians)
fields = ['close'], # which fields to download
vendor_tickers = ['aapl', 'spy'], # ticker (Google)
vendor_fields = ['Close'], # which Bloomberg fields to download
cache_algo = 'internet_load_return') # how to return data
ltsf = LightTimeSeriesFactory()
tsc = TimeSeriesCalcs()
df = tsc.create_mult_index_from_prices(ltsf.harvest_time_series(time_series_request))
gp = GraphProperties()
gp.html_file_output = "output_data/apple.htm"
gp.title = "S&P500 vs Apple"
# plot first with PyThalesians and then Bokeh
# just needs 1 word to change
gp.display_legend = False
pf = PlotFactory()
pf.plot_generic_graph(df, type = 'line', adapter = 'pythalesians', gp = gp)
pf.plot_generic_graph(df, type = 'line', adapter = 'bokeh', gp = gp)
# test simple Bokeh bar charts - monthly returns over past 6 months
if True:
fields = ['close'], # which fields to download
vendor_tickers = vendor_tickers, # ticker (Bloomberg)
vendor_fields = ['PX_LAST'], # which Bloomberg fields to download
cache_algo = 'internet_load_return') # how to return data
# We now pass this TimeSeriesRequest object to a LightTimeSeriesFactory, which will return a pandas dataframe from the data source and will also output logger text (we can edit logging.conf to make this less verbose or to change the output of the log to disk, rather than screen, however, I've included it, so we can see which classes are being called).
#
# By default, PyThalesians will split up the ticker download into several chunks, using multithreading to make several calls to our data source. The number of threads can be changed in the Constants.py file (we can also specify if we would prefer to use multiprocessing as opposed to multithreading, which gets around the Python GIL. In most cases, however, the overhead of doing this is unnecessary).
# In[ ]:
from pythalesians.market.loaders.lighttimeseriesfactory import LightTimeSeriesFactory
ltsf = LightTimeSeriesFactory()
daily_vals = ltsf.harvest_time_series(time_series_request)
# We now have the various time series in a pandas dataframe. We can rebase all the datapoints using a function in TimeSeriesCalcs
# In[ ]:
from pythalesians.timeseries.calcs.timeseriescalcs import TimeSeriesCalcs
tsc = TimeSeriesCalcs()
df = tsc.create_mult_index_from_prices(daily_vals)
df = df.fillna(method='ffill')
# Lastly we can plot the results! We shall plot it with the PlotFactory class using PyThalesians engine (a wrapper on top of matplotlib). We can specify the properties of the plot using a GraphProperties class. The first line, forces matplotlib to give us the plot in the notebook, as opposed to a separate window.
# tickers for overnight deposit data, which is necessary for computing total return indices
time_series_request_deposit = copy.copy(time_series_request_spot)
time_series_request_deposit.tickers = ['EURON', 'USDON', 'GBPON', 'AUDON']
time_series_request_deposit.vendor_tickers = ['EUDR1T CMPN Curncy', 'USDR1T CMPN Curncy',
'BPDR1T CMPN Curncy', 'ADDR1T CMPN Curncy']
# tickers for getting total return indices from Bloomberg directly
time_series_request_total_ret = copy.copy(time_series_request_spot)
time_series_request_total_ret.tickers = ['EURUSD', 'GBPUSD', 'AUDUSD']
time_series_request_total_ret.vendor_tickers = ['EURUSDCR BGN Curncy', 'GBPUSDCR BGN Curncy', 'AUDUSDCR BGN Curncy']
ltsf = LightTimeSeriesFactory()
df = None
spot_df = ltsf.harvest_time_series(time_series_request_spot)
deposit_df = ltsf.harvest_time_series(time_series_request_deposit)
deposit_df = deposit_df.fillna(method = 'ffill')
deposit_df = deposit_df.fillna(method = 'bfill') # bit of a hack - because some deposit data sparse
tot_df = ltsf.harvest_time_series(time_series_request_total_ret)
tsc = TimeSeriesCalcs()
tot_df = tsc.create_mult_index_from_prices(tot_df) # rebase index at 100
# we can change the
tenor = 'ON'
# plot total return series comparison for all our crosses
# in practice, we would typically make a set of xxxUSD total return indices
# and use them to compute all other crosses (assuming we are USD denominated investor)
time_series_request = TimeSeriesRequest(
start_date="01 Jan 1970", # start date
finish_date=datetime.date.today(), # finish date
freq='daily', # daily data
data_source='quandl', # use Quandl as data source
tickers=['EURUSD', # ticker (Thalesians)
'GBPUSD'],
fields=['close'], # which fields to download
vendor_tickers=['FRED/DEXUSEU', 'FRED/DEXUSUK'], # ticker (Quandl)
vendor_fields=['close'], # which Bloomberg fields to download
cache_algo='internet_load_return') # how to return data
ltsf = LightTimeSeriesFactory()
daily_vals = ltsf.harvest_time_series(time_series_request)
techind = TechIndicator()
tech_params = TechParams()
tech_params.sma_period = 20
techind.create_tech_ind(daily_vals, 'SMA', tech_params=tech_params)
sma = techind.get_techind()
signal = techind.get_signal()
combine = daily_vals.join(sma, how='outer')
pf = PlotFactory()
pf.plot_line_graph(combine, adapter='pythalesians')
class HistEconDataFactory:
def __init__(self):
self.logger = LoggerManager().getLogger(__name__)
self._all_econ_tickers = pandas.read_csv(Constants().all_econ_tickers)
self._econ_country_codes = pandas.read_csv(
Constants().econ_country_codes)
self._econ_country_groups = pandas.read_csv(
Constants().econ_country_groups)
self.time_series_factory = LightTimeSeriesFactory()
# if Constants().default_time_series_factory == 'lighttimeseriesfactory':
# self.time_series_factory = LightTimeSeriesFactory()
# else:
# self.time_series_factory = CachedTimeSeriesFactory()
# return
def get_economic_data_history(self,
start_date,
finish_date,
country_group,
data_type,
source='fred',
cache_algo="internet_load_return"):
#vendor_country_codes = self.fred_country_codes[country_group]
#vendor_pretty_country = self.fred_nice_country_codes[country_group]
if isinstance(country_group, list):
pretty_country_names = country_group
else:
# get all the country names in the country_group
pretty_country_names = list(self._econ_country_groups[
self._econ_country_groups["Country Group"] == country_group]
['Country'])
# construct the pretty tickers
pretty_tickers = [x + '-' + data_type for x in pretty_country_names]
# get vendor tickers
vendor_tickers = []
for pretty_ticker in pretty_tickers:
vendor_ticker = list(
self._all_econ_tickers[self._all_econ_tickers["Full Code"] ==
pretty_ticker][source].values)
if vendor_ticker == []:
vendor_ticker = None
self.logger.error('Could not find match for ' + pretty_ticker)
else:
vendor_ticker = vendor_ticker[0]
vendor_tickers.append(vendor_ticker)
vendor_fields = ['close']
if source == 'bloomberg': vendor_fields = ['PX_LAST']
time_series_request = TimeSeriesRequest(
start_date=start_date, # start date
finish_date=finish_date, # finish date
category='economic',
freq='daily', # intraday data
data_source=source, # use Bloomberg as data source
cut='LOC',
tickers=pretty_tickers,
fields=['close'], # which fields to download
vendor_tickers=vendor_tickers,
vendor_fields=vendor_fields, # which Bloomberg fields to download
cache_algo=cache_algo) # how to return data
return self.time_series_factory.harvest_time_series(
time_series_request)
def grasp_coded_entry(self, df, index):
df = df.ix[index:].stack()
df = df.reset_index()
df.columns = ['Date', 'Name', 'Val']
countries = df['Name']
countries = [x.split('-', 1)[0] for x in countries]
df['Code'] = sum([
list(self._econ_country_codes[self._econ_country_codes["Country"]
== x]['Code']) for x in countries
], [])
return df
time_series_request = TimeSeriesRequest(
start_date = start_date, # start date
finish_date = finish_date, # finish date
category = "events",
freq = 'daily', # daily data
data_source = 'bloomberg', # use Bloomberg as data source
tickers = ['NFP'],
fields = ['release-date-time-full'], # which fields to download
vendor_tickers = ['NFP TCH Index'], # ticker (Bloomberg)
vendor_fields = ['ECO_FUTURE_RELEASE_DATE_LIST'], # which Bloomberg fields to download
cache_algo = 'internet_load_return') # how to return data
ltsf = LightTimeSeriesFactory()
ts_filter = TimeSeriesFilter()
df_event_times = ltsf.harvest_time_series(time_series_request)
utc_time = pytz.utc
df_event_times = pandas.DataFrame(index = df_event_times['NFP.release-date-time-full'])
df_event_times.index = df_event_times.index.tz_localize(utc_time) # work in UTC time
df_event_times = ts_filter.filter_time_series_by_date(start_date, finish_date, df_event_times)
# get last NFP time
start_date = df_event_times.index[-1] - timedelta(minutes=1)
finish_date = start_date + timedelta(minutes=4)
tickers = ['EURUSD', 'JPYUSD', 'GBPUSD']
vendor_tickers = ['EURUSD BGN Curncy', 'USDJPY BGN Curncy', 'GBPUSD BGN Curncy']
# Bloomberg will give tick data which is downsampled within the LightTimeSeriesFactory class
time_series_request = TimeSeriesRequest(
time_series_request = TimeSeriesRequest(
start_date = start_date, # start date
finish_date = finish_date, # finish date
category = "events",
freq = 'daily', # daily data
data_source = 'bloomberg', # use Bloomberg as data source
tickers = ['NFP'],
fields = ['release-date-time-full'], # which fields to download
vendor_tickers = ['NFP TCH Index'], # ticker (Bloomberg)
vendor_fields = ['ECO_FUTURE_RELEASE_DATE_LIST'], # which Bloomberg fields to download
cache_algo = 'internet_load_return') # how to return data
ltsf = LightTimeSeriesFactory()
ts_filter = TimeSeriesFilter()
df_event_times = ltsf.harvest_time_series(time_series_request)
utc_time = pytz.utc
df_event_times = pandas.DataFrame(index = df_event_times['NFP.release-date-time-full'])
df_event_times.index = df_event_times.index.tz_localize(utc_time) # work in UTC time
df_event_times = ts_filter.filter_time_series_by_date(start_date, finish_date, df_event_times)
# get last NFP time
start_date = df_event_times.index[-1] - timedelta(minutes=1)
finish_date = start_date + timedelta(minutes=4)
tickers = ['EURUSD', 'JPYUSD', 'GBPUSD']
vendor_tickers = ['EURUSD BGN Curncy', 'USDJPY BGN Curncy', 'GBPUSD BGN Curncy']
# Bloomberg will give tick data which is downsampled within the LightTimeSeriesFactory class
time_series_request = TimeSeriesRequest(
if True:
time_series_request = TimeSeriesRequest(
start_date = "01 Jan 2013", # start date
finish_date = datetime.date.today(), # finish date
freq = 'daily', # daily data
data_source = 'google', # use Bloomberg as data source
tickers = ['Apple', 'S&P500 ETF'], # ticker (Thalesians)
fields = ['close'], # which fields to download
vendor_tickers = ['aapl', 'spy'], # ticker (Google)
vendor_fields = ['Close'], # which Bloomberg fields to download
cache_algo = 'internet_load_return') # how to return data
ltsf = LightTimeSeriesFactory()
tsc = TimeSeriesCalcs()
df = tsc.create_mult_index_from_prices(ltsf.harvest_time_series(time_series_request))
gp = GraphProperties()
gp.html_file_output = "output_data/apple.htm"
gp.title = "S&P500 vs Apple"
# plot first with PyThalesians and then Bokeh
# just needs 1 word to change
gp.display_legend = False
pf = PlotFactory()
pf.plot_generic_graph(df, type = 'line', adapter = 'pythalesians', gp = gp)
pf.plot_generic_graph(df, type = 'line', adapter = 'bokeh', gp = gp)
# test simple Bokeh bar charts - monthly returns over past 6 months
if True:
class HistEconDataFactory:
def __init__(self):
self.logger = LoggerManager().getLogger(__name__)
self._all_econ_tickers = pandas.read_csv(Constants().all_econ_tickers)
self._econ_country_codes = pandas.read_csv(Constants().econ_country_codes)
self._econ_country_groups = pandas.read_csv(Constants().econ_country_groups)
self.time_series_factory = LightTimeSeriesFactory()
# if Constants().default_time_series_factory == 'lighttimeseriesfactory':
# self.time_series_factory = LightTimeSeriesFactory()
# else:
# self.time_series_factory = CachedTimeSeriesFactory()
# return
def get_economic_data_history(
self, start_date, finish_date, country_group, data_type, source="fred", cache_algo="internet_load_return"
):
# vendor_country_codes = self.fred_country_codes[country_group]
# vendor_pretty_country = self.fred_nice_country_codes[country_group]
if isinstance(country_group, list):
pretty_country_names = country_group
else:
# get all the country names in the country_group
pretty_country_names = list(
self._econ_country_groups[self._econ_country_groups["Country Group"] == country_group]["Country"]
)
# construct the pretty tickers
pretty_tickers = [x + "-" + data_type for x in pretty_country_names]
# get vendor tickers
vendor_tickers = []
for pretty_ticker in pretty_tickers:
vendor_ticker = list(
self._all_econ_tickers[self._all_econ_tickers["Full Code"] == pretty_ticker][source].values
)
if vendor_ticker == []:
vendor_ticker = None
self.logger.error("Could not find match for " + pretty_ticker)
else:
vendor_ticker = vendor_ticker[0]
vendor_tickers.append(vendor_ticker)
vendor_fields = ["close"]
if source == "bloomberg":
vendor_fields = ["PX_LAST"]
time_series_request = TimeSeriesRequest(
start_date=start_date, # start date
finish_date=finish_date, # finish date
category="economic",
freq="daily", # intraday data
data_source=source, # use Bloomberg as data source
cut="LOC",
tickers=pretty_tickers,
fields=["close"], # which fields to download
vendor_tickers=vendor_tickers,
vendor_fields=vendor_fields, # which Bloomberg fields to download
cache_algo=cache_algo,
) # how to return data
return self.time_series_factory.harvest_time_series(time_series_request)
def grasp_coded_entry(self, df, index):
df = df.ix[index:].stack()
df = df.reset_index()
df.columns = ["Date", "Name", "Val"]
countries = df["Name"]
countries = [x.split("-", 1)[0] for x in countries]
df["Code"] = sum(
[list(self._econ_country_codes[self._econ_country_codes["Country"] == x]["Code"]) for x in countries], []
)
return df
]
time_series_request = TimeSeriesRequest(
start_date="01 Jan 1989", # start date
finish_date=datetime.date.today(), # finish date
freq='daily', # daily data
data_source='quandl', # use Quandl as data source
tickers=tickers, # ticker (Thalesians)
fields=['close'], # which fields to download
vendor_tickers=vendor_tickers, # ticker (Quandl)
vendor_fields=['close'], # which Bloomberg fields to download
cache_algo='internet_load_return') # how to return data
ltsf = LightTimeSeriesFactory()
asset_df = ltsf.harvest_time_series(time_series_request)
spot_df = asset_df
logger.info("Running backtest...")
# use technical indicator to create signals
# (we could obviously create whatever function we wanted for generating the signal dataframe)
tech_ind = TechIndicator()
tech_ind.create_tech_ind(spot_df, indicator, tech_params)
signal_df = tech_ind.get_signal()
# use the same data for generating signals
cash_backtest.calculate_trading_PnL(br, asset_df, signal_df)
port = cash_backtest.get_cumportfolio()
port.columns = [
indicator + ' = ' + str(tech_params.sma_period) + ' ' +
thread_no = [1,2,3,4]
thread_technique = ["thread", "multiprocessor"]
diag = []
for tech in thread_technique:
# change the static variable in Constants which govern the threading we use
Constants.time_series_factory_thread_technique = tech
for no in thread_no:
for key in Constants.time_series_factory_thread_no:
Constants.time_series_factory_thread_no[key] = no
import time
start = time.time();
df = ltsf.harvest_time_series(time_series_request);
end = time.time()
duration = end - start
diag.append("With " + str(no) + " " + tech + " no: " + str(duration) + " seconds")
for d in diag:
logger.info(d)
###### download intraday data from Bloomberg for FX, with different threading techniques
if True:
from datetime import timedelta
time_series_request = TimeSeriesRequest(
start_date = datetime.date.today() - timedelta(days=10), # start date
