def run_day_of_month_analysis(self, strat):
from pythalesians.economics.seasonality.seasonality import Seasonality
from pythalesians.timeseries.calcs.timeseriescalcs import TimeSeriesCalcs
tsc = TimeSeriesCalcs()
seas = Seasonality()
strat.construct_strategy()
pnl = strat.get_strategy_pnl()
# get seasonality by day of the month
pnl = pnl.resample('B').mean()
rets = tsc.calculate_returns(pnl)
bus_day = seas.bus_day_of_month_seasonality(rets, add_average = True)
# get seasonality by month
pnl = pnl.resample('BM').mean()
rets = tsc.calculate_returns(pnl)
month = seas.monthly_seasonality(rets)
self.logger.info("About to plot seasonality...")
gp = GraphProperties()
pf = PlotFactory()
# Plotting spot over day of month/month of year
gp.color = 'Blues'
gp.scale_factor = self.SCALE_FACTOR
gp.file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' seasonality day of month.png'
gp.html_file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' seasonality day of month.html'
gp.title = strat.FINAL_STRATEGY + ' day of month seasonality'
gp.display_legend = False
gp.color_2_series = [bus_day.columns[-1]]
gp.color_2 = ['red'] # red, pink
gp.linewidth_2 = 4
gp.linewidth_2_series = [bus_day.columns[-1]]
gp.y_axis_2_series = [bus_day.columns[-1]]
pf.plot_line_graph(bus_day, adapter = self.DEFAULT_PLOT_ENGINE, gp = gp)
gp = GraphProperties()
gp.scale_factor = self.SCALE_FACTOR
gp.file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' seasonality month of year.png'
gp.html_file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' seasonality month of year.html'
gp.title = strat.FINAL_STRATEGY + ' month of year seasonality'
pf.plot_line_graph(month, adapter = self.DEFAULT_PLOT_ENGINE, gp = gp)
return month
def g10_plot_gdp_cpi_une(self, start_date, finish_date, data_type='cpi'):
country_group = 'g10'
if data_type == 'cpi':
df = self.get_CPI_YoY(start_date, finish_date, country_group)
elif data_type == 'gdp':
df = self.get_GDP_QoQ(start_date, finish_date, country_group)
elif data_type == 'une':
df = self.get_UNE(start_date, finish_date, country_group)
df = self.hist_econ_data_factory.grasp_coded_entry(df, -1)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.plotly_location_mode = 'world'
gp.plotly_choropleth_field = 'Val'
gp.plotly_scope = 'world'
gp.plotly_projection = 'Mercator'
gp.plotly_world_readable = False
gp.plotly_url = country_group + "-" + data_type
gp.title = "G10 " + data_type
gp.units = '%'
pf.plot_generic_graph(df, type='choropleth', adapter='plotly', gp=gp)
def g10_line_plot_gdp(self, start_date, finish_date):
today_root = datetime.date.today().strftime("%Y%m%d") + " "
country_group = 'g10-ez'
gdp = self.get_GDP_QoQ(start_date, finish_date, country_group)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.title = "G10 GDP"
gp.units = 'Rebased'
gp.scale_factor = Constants.plotfactory_scale_factor
gp.file_output = today_root + 'G10 UNE ' + str(
gp.scale_factor) + '.png'
gdp.columns = [x.split('-')[0] for x in gdp.columns]
gp.linewidth_2 = 3
gp.linewidth_2_series = ['United Kingdom']
from pythalesians.timeseries.calcs.timeseriescalcs import TimeSeriesCalcs
tsc = TimeSeriesCalcs()
gdp = gdp / 100
gdp = tsc.create_mult_index_from_prices(gdp)
pf.plot_generic_graph(gdp, type='line', adapter='pythalesians', gp=gp)
def usa_plot_une(self, start_date, finish_date):
country_group = 'usa-states'
source = 'bloomberg'
une = self.get_UNE(start_date,
finish_date,
country_group,
source='bloomberg')
une = self.hist_econ_data_factory.grasp_coded_entry(une, -1)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.plotly_location_mode = 'USA-states'
gp.plotly_choropleth_field = 'Val'
gp.plotly_scope = 'usa'
gp.plotly_projection = 'albers usa'
gp.plotly_world_readable = False
gp.plotly_url = country_group + "-unemployment"
gp.title = "USA Unemployment"
gp.units = 'pc'
pf.plot_generic_graph(une, type='choropleth', adapter='plotly', gp=gp)
def g10_plot_gdp_cpi_une(self, start_date, finish_date, data_type = 'cpi'):
country_group = 'g10'
if data_type == 'cpi':
df = self.get_CPI_YoY(start_date, finish_date, country_group)
elif data_type == 'gdp':
df = self.get_GDP_QoQ(start_date, finish_date, country_group)
elif data_type == 'une':
df = self.get_UNE(start_date, finish_date, country_group)
df = self.hist_econ_data_factory.grasp_coded_entry(df, -1)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.plotly_location_mode = 'world'
gp.plotly_choropleth_field = 'Val'
gp.plotly_scope = 'world'
gp.plotly_projection = 'Mercator'
gp.plotly_world_readable = False
gp.plotly_url = country_group + "-" + data_type
gp.title = "G10 " + data_type
gp.units = '%'
pf.plot_generic_graph(df, type = 'choropleth', adapter = 'plotly', gp = gp)
def plot_single_var_regression(self, y, x, y_variable_names, x_variable_names, statistic,
tag = 'stats',
title = None,
pretty_index = None, output_path = None,
scale_factor = Constants.plotfactory_scale_factor,
silent_plot = False,
shift=[0]):
if not(isinstance(statistic, list)):
statistic = [statistic]
# TODO optimise loop so that we are calculating each regression *once* at present calculating it
# for each statistic, which is redundant
for st in statistic:
stats_df = []
for sh in shift:
x_sh = x.shift(sh)
stats_temp = self.report_single_var_regression(y, x_sh, y_variable_names, x_variable_names, st,
pretty_index)
stats_temp.columns = [ x + "_" + str(sh) for x in stats_temp.columns]
stats_df.append(stats_temp)
stats_df = pandas.concat(stats_df, axis=1)
stats_df = stats_df.dropna(how='all')
if silent_plot: return stats_df
pf = PlotFactory()
gp = GraphProperties()
if title is None: title = statistic
gp.title = title
gp.display_legend = True
gp.scale_factor = scale_factor
# gp.color = ['red', 'blue', 'purple', 'gray', 'yellow', 'green', 'pink']
if output_path is not None:
gp.file_output = output_path + ' (' + tag + ' ' + st + ').png'
pf.plot_bar_graph(stats_df, adapter = 'pythalesians', gp = gp)
return stats_df
def create_graph_properties(self, title, file_add):
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY + " " + title
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
if self.DEFAULT_PLOT_ENGINE != 'cufflinks':
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (' + file_add + ') ' + str(gp.scale_factor) + '.png'
gp.html_file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (' + file_add + ') ' + str(gp.scale_factor) + '.html'
try:
gp.silent_display = self.SILENT_DISPLAY
except: pass
return gp
def g10_line_plot_une(self, start_date, finish_date):
today_root = datetime.date.today().strftime("%Y%m%d") + " "
country_group = 'g10-ez'
une = self.get_UNE(start_date, finish_date, country_group)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.title = "G10 Unemployment Rate (%)"
gp.units = '%'
gp.scale_factor = Constants.plotfactory_scale_factor
gp.file_output = today_root + 'G10 UNE ' + str(gp.scale_factor) + '.png'
une.columns = [x.split('-')[0] for x in une.columns]
gp.linewidth_2 = 3
gp.linewidth_2_series = ['United States']
pf.plot_generic_graph(une, type = 'line', adapter = 'pythalesians', gp = gp)
def g10_line_plot_une(self, start_date, finish_date):
today_root = datetime.date.today().strftime("%Y%m%d") + " "
country_group = 'g10-ez'
une = self.get_UNE(start_date, finish_date, country_group)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.title = "G10 Unemployment Rate (%)"
gp.units = '%'
gp.scale_factor = Constants.plotfactory_scale_factor
gp.file_output = today_root + 'G10 UNE ' + str(
gp.scale_factor) + '.png'
une.columns = [x.split('-')[0] for x in une.columns]
gp.linewidth_2 = 3
gp.linewidth_2_series = ['United States']
pf.plot_generic_graph(une, type='line', adapter='pythalesians', gp=gp)
def usa_plot_une(self, start_date, finish_date):
country_group = 'usa-states'; source = 'bloomberg'
une = self.get_UNE(start_date, finish_date, country_group, source = 'bloomberg')
une = self.hist_econ_data_factory.grasp_coded_entry(une, -1)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.plotly_location_mode = 'USA-states'
gp.plotly_choropleth_field = 'Val'
gp.plotly_scope = 'usa'
gp.plotly_projection = 'albers usa'
gp.plotly_world_readable = False
gp.plotly_url = country_group + "-unemployment"
gp.title = "USA Unemployment"
gp.units = 'pc'
pf.plot_generic_graph(une, type = 'choropleth', adapter = 'plotly', gp = gp)
def europe_plot_une(self, start_date, finish_date):
country_group = 'all-europe'
une = self.get_UNE(start_date, finish_date, country_group)
une = self.hist_econ_data_factory.grasp_coded_entry(une, -1)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.plotly_location_mode = 'europe'
gp.plotly_choropleth_field = 'Val'
gp.plotly_scope = 'europe'
gp.plotly_projection = 'Mercator'
gp.plotly_world_readable = False
gp.plotly_url = country_group + "-unemployment"; gp.title = "Europe Unemployment"
gp.units = '%'
pf.plot_generic_graph(une, type = 'choropleth', adapter = 'plotly', gp = gp)
def world_plot_cpi(self, start_date, finish_date):
country_group = 'world-liquid'
cpi = self.get_CPI_YoY(start_date, finish_date, country_group)
cpi = self.hist_econ_data_factory.grasp_coded_entry(cpi, -1)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.plotly_location_mode = 'world'
gp.plotly_choropleth_field = 'Val'
gp.plotly_scope = 'world'
gp.plotly_projection = 'Mercator'
gp.plotly_world_readable = False
gp.plotly_url = str(country_group) + "-cpi"
gp.title = "World Liquid CPI YoY"
gp.units = '%'
pf.plot_generic_graph(cpi, type='choropleth', adapter='plotly', gp=gp)
def g10_line_plot_gdp(self, start_date, finish_date):
today_root = datetime.date.today().strftime("%Y%m%d") + " "
country_group = 'g10-ez'
gdp = self.get_GDP_QoQ(start_date, finish_date, country_group)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.title = "G10 GDP"
gp.units = 'Rebased'
gp.scale_factor = Constants.plotfactory_scale_factor
gp.file_output = today_root + 'G10 UNE ' + str(gp.scale_factor) + '.png'
gdp.columns = [x.split('-')[0] for x in gdp.columns]
gp.linewidth_2 = 3
gp.linewidth_2_series = ['United Kingdom']
from pythalesians.timeseries.calcs.timeseriescalcs import TimeSeriesCalcs
tsc = TimeSeriesCalcs()
gdp = gdp / 100
gdp = tsc.create_mult_index_from_prices(gdp)
pf.plot_generic_graph(gdp, type = 'line', adapter = 'pythalesians', gp = gp)
def world_plot_cpi(self, start_date, finish_date):
country_group = 'world-liquid'
cpi = self.get_CPI_YoY(start_date, finish_date, country_group)
cpi = self.hist_econ_data_factory.grasp_coded_entry(cpi, -1)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.plotly_location_mode = 'world'
gp.plotly_choropleth_field = 'Val'
gp.plotly_scope = 'world'
gp.plotly_projection = 'Mercator'
gp.plotly_world_readable = False
gp.plotly_url = str(country_group) + "-cpi"
gp.title = "World Liquid CPI YoY"
gp.units = '%'
pf.plot_generic_graph(cpi, type = 'choropleth', adapter = 'plotly', gp = gp)
def europe_plot_une(self, start_date, finish_date):
country_group = 'all-europe'
une = self.get_UNE(start_date, finish_date, country_group)
une = self.hist_econ_data_factory.grasp_coded_entry(une, -1)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.plotly_location_mode = 'europe'
gp.plotly_choropleth_field = 'Val'
gp.plotly_scope = 'europe'
gp.plotly_projection = 'Mercator'
gp.plotly_world_readable = False
gp.plotly_url = country_group + "-unemployment"
gp.title = "Europe Unemployment"
gp.units = '%'
pf.plot_generic_graph(une, type='choropleth', adapter='plotly', gp=gp)
df = hist.grasp_coded_entry(df, -1)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.plotly_location_mode = 'USA-states'
gp.plotly_choropleth_field = 'Val'
gp.plotly_scope = 'usa'
gp.plotly_projection = 'albers usa'
gp.plotly_url = country_group + data_type.replace(' ', '-')
gp.plotly_world_readable = False
gp.title = title
gp.units = 'Value'
# do a map plot by US state
pf.plot_generic_graph(df, type='choropleth', adapter='cufflinks', gp=gp)
#### uses CommonEconDataFactory to get more common forms of economic data and plot
####
if True:
logger = LoggerManager.getLogger(__name__)
cedf = CommonEconDataFactory()
start_date = '01 Jan 2014'
finish_date = datetime.datetime.utcnow()
# select as appropriate!
df = tsc.calculate_returns(df) * 100
df = df.dropna()
df_sorted = tsc.get_bottom_valued_sorted(df, "USDBRL", n=20)
# df = tsc.get_top_valued_sorted(df, "USDBRL", n = 20) # get biggest up moves
# get values on day after
df2 = df.shift(-1)
df2 = df2.ix[df_sorted.index]
df2.columns = ['T+1']
df_sorted.columns = ['T']
df_sorted = df_sorted.join(df2)
df_sorted.index = [
str(x.year) + '/' + str(x.month) + '/' + str(x.day)
for x in df_sorted.index
]
gp = GraphProperties()
gp.title = 'Largest daily falls in USDBRL'
gp.scale_factor = 3
gp.display_legend = True
gp.chart_type = 'bar'
gp.x_title = 'Dates'
gp.y_title = 'Pc'
gp.file_output = "usdbrl-biggest-downmoves.png"
pf = PlotFactory()
pf.plot_line_graph(df_sorted, adapter='pythalesians', gp=gp)
df_fred = ltsf.harvest_time_series(time_series_request)
df_fred.columns = [
x.replace('.close', '') for x in df_fred.columns.values
]
# convert to USD bn
# df_fred = (df_fred * 10000000)
df = df.join(df_fred, how="outer")
df['USDJPY'] = df['USDJPY'].ffill()
# data is in 100 million JPY, divide by 10 to get into 1000 million (ie. 1 billion)
# divide by USD/JPY spot to get into USD
df['USDJPY purchases (bn USD)'] = (df['USDJPY purchases (bn USD)'] /
df['USDJPY']) / 10
gp = GraphProperties()
gp.scale_factor = 3
gp.title = "BoJ USDJPY buying"
gp.file_output = "output_data/" + datetime.date.today().strftime("%Y%m%d") + " USDJPY BoJ intervention " \
+ str(gp.scale_factor) + ".png"
gp.source = 'Thalesians/BBG (created with PyThalesians Python library)'
gp.y_axis_2_series = ['USDJPY purchases (bn USD)']
gp.color_2_series = gp.y_axis_2_series
gp.color_2 = ['blue']
pf = PlotFactory()
pf.plot_line_graph(df, adapter='pythalesians', gp=gp)
from pythalesians.market.loaders.lighttimeseriesfactory import LightTimeSeriesFactory
from pythalesians.market.requests.timeseriesrequest import TimeSeriesRequest
from pythalesians.timeseries.calcs.timeseriescalcs import TimeSeriesCalcs
if True:
import pandas
df = pandas.read_csv(
"volsurface.csv") # load a snapshot for a vol surface from disk
gp = GraphProperties()
gp.plotly_plot_mode = "offline_html" # render Plotly plot locally (rather than via website)
gp.file_output = "volsurface.png" # save as static PNG file
gp.html_file_output = "volsurface.html" # save as interactive HTML file
gp.title = "GBP/USD vol surface"
gp.color = 'Blues'
# plot surface with Plotly
pf = PlotFactory()
pf.plot_generic_graph(df, type='surface', adapter='cufflinks', 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
df = ltsf.harvest_time_series(time_series_request)
df.columns = [x.replace('.close', '') for x in df.columns.values]
df = tsc.calculate_returns(df) * 100
df = df.dropna()
df_sorted = tsc.get_bottom_valued_sorted(df, "USDBRL", n = 20)
# df = tsc.get_top_valued_sorted(df, "USDBRL", n = 20) # get biggest up moves
# get values on day after
df2 = df.shift(-1)
df2 = df2.ix[df_sorted.index]
df2.columns = ['T+1']
df_sorted.columns = ['T']
df_sorted = df_sorted.join(df2)
df_sorted.index = [str(x.year) + '/' + str(x.month) + '/' + str(x.day) for x in df_sorted.index]
gp = GraphProperties()
gp.title = 'Largest daily falls in USDBRL'
gp.scale_factor = 3
gp.display_legend = True
gp.chart_type = 'bar'
gp.x_title = 'Dates'
gp.y_title = 'Pc'
gp.file_output = "usdbrl-biggest-downmoves.png"
pf = PlotFactory()
pf.plot_line_graph(df_sorted, adapter = 'pythalesians', gp=gp)
df = hist.grasp_coded_entry(df, -1)
from chartesians.graphs import PlotFactory
from chartesians.graphs.graphproperties import GraphProperties
gp = GraphProperties()
pf = PlotFactory()
gp.plotly_location_mode = 'USA-states'
gp.plotly_choropleth_field = 'Val'
gp.plotly_scope = 'usa'
gp.plotly_projection = 'albers usa'
gp.plotly_url = country_group + data_type.replace(' ', '-')
gp.plotly_world_readable = False
gp.title = title
gp.units = 'Value'
# do a map plot by US state
pf.plot_generic_graph(df, type = 'choropleth', adapter = 'cufflinks', gp = gp)
#### uses CommonEconDataFactory to get more common forms of economic data and plot
####
if True:
logger = LoggerManager.getLogger(__name__)
cedf = CommonEconDataFactory()
start_date = '01 Jan 2014'
finish_date = datetime.datetime.utcnow()
# select as appropriate!
finish_date=datetime.date.today(), # finish date
freq='daily', # daily data
data_source='bloomberg', # use Bloomberg as data source
tickers=tickers, # ticker (Thalesians)
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
daily_vals = ltsf.harvest_time_series(time_series_request)
pf = PlotFactory()
gp = GraphProperties()
gp.title = 'Spot values'
gp.file_output = 'output_data/demo.png'
gp.html_file_output = 'output_data/demo.htm'
gp.source = 'Thalesians/BBG'
# plot using PyThalesians
pf.plot_line_graph(daily_vals, adapter='pythalesians', gp=gp)
# plot using Bokeh (still needs a lot of work!)
pf.plot_line_graph(daily_vals, adapter='bokeh', gp=gp)
# do more complicated charts using several different Matplotib stylesheets (which have been customised)
if False:
ltsf = LightTimeSeriesFactory()
# load market data
fields=['close'], # which fields to download
vendor_tickers=vendor_tickers,
vendor_fields=['close'], # which Bloomberg fields to download
cache_algo='internet_load_return') # how to return data
df = ltsf.harvest_time_series(time_series_request)
df.columns = [x.replace('.close', '') for x in df.columns.values]
# Bloomberg does not give the milisecond field when you make a tick request, so might as well downsample to S
df['JPYUSD'] = 1 / df['JPYUSD']
gp = GraphProperties()
pf = PlotFactory()
gp.scale_factor = 3
gp.title = 'FX around last NFP date'
gp.source = 'Thalesians/BBG (created with PyThalesians Python library)'
tsc = TimeSeriesCalcs()
df = tsc.create_mult_index_from_prices(df)
pf.plot_line_graph(df, adapter='pythalesians', gp=gp)
###### download tick data from Bloomberg for EUR/USD around last FOMC and then downsample to plot
if True:
finish_date = datetime.datetime.utcnow()
start_date = finish_date - timedelta(days=60)
# fetch Fed times from Bloomberg
time_series_request = TimeSeriesRequest(
start_date=start_date, # start date
def run_arbitrary_sensitivity(self, strat, parameter_list = None, parameter_names = None,
pretty_portfolio_names = None, parameter_type = None):
asset_df, spot_df, spot_df2, basket_dict = strat.fill_assets()
port_list = None
tsd_list = []
for i in range(0, len(parameter_list)):
br = strat.fill_backtest_request()
current_parameter = parameter_list[i]
# for calculating P&L
for k in current_parameter.keys():
setattr(br, k, current_parameter[k])
strat.br = br # for calculating signals
signal_df = strat.construct_signal(spot_df, spot_df2, br.tech_params, br)
cash_backtest = CashBacktest()
self.logger.info("Calculating... " + pretty_portfolio_names[i])
cash_backtest.calculate_trading_PnL(br, asset_df, signal_df)
tsd_list.append(cash_backtest.get_portfolio_pnl_tsd())
stats = str(cash_backtest.get_portfolio_pnl_desc()[0])
port = cash_backtest.get_cumportfolio().resample('B').mean()
port.columns = [pretty_portfolio_names[i] + ' ' + stats]
if port_list is None:
port_list = port
else:
port_list = port_list.join(port)
# reset the parameters of the strategy
strat.br = strat.fill_backtest_request()
pf = PlotFactory()
gp = GraphProperties()
ir = [t.inforatio()[0] for t in tsd_list]
# gp.color = 'Blues'
# plot all the variations
gp.resample = 'B'
gp.file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' ' + parameter_type + '.png'
gp.scale_factor = self.scale_factor
gp.title = strat.FINAL_STRATEGY + ' ' + parameter_type
pf.plot_line_graph(port_list, adapter = 'pythalesians', gp = gp)
# plot all the IR in a bar chart form (can be easier to read!)
gp = GraphProperties()
gp.file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' ' + parameter_type + ' IR.png'
gp.scale_factor = self.scale_factor
gp.title = strat.FINAL_STRATEGY + ' ' + parameter_type
summary = pandas.DataFrame(index = pretty_portfolio_names, data = ir, columns = ['IR'])
pf.plot_bar_graph(summary, adapter = 'pythalesians', gp = gp)
return port_list
def run_arbitrary_sensitivity(self, strat, parameter_list = None, parameter_names = None,
pretty_portfolio_names = None, parameter_type = None):
asset_df, spot_df, spot_df2, basket_dict = strat.fill_assets()
port_list = None
tsd_list = []
for i in range(0, len(parameter_list)):
br = strat.fill_backtest_request()
current_parameter = parameter_list[i]
# for calculating P&L
for k in current_parameter.keys():
setattr(br, k, current_parameter[k])
strat.br = br # for calculating signals
signal_df = strat.construct_signal(spot_df, spot_df2, br.tech_params, br)
cash_backtest = CashBacktest()
self.logger.info("Calculating... " + str(pretty_portfolio_names[i]))
cash_backtest.calculate_trading_PnL(br, asset_df, signal_df)
tsd_list.append(cash_backtest.get_portfolio_pnl_tsd())
stats = str(cash_backtest.get_portfolio_pnl_desc()[0])
port = cash_backtest.get_cumportfolio().resample('B').mean()
port.columns = [str(pretty_portfolio_names[i]) + ' ' + stats]
if port_list is None:
port_list = port
else:
port_list = port_list.join(port)
# reset the parameters of the strategy
strat.br = strat.fill_backtest_request()
pf = PlotFactory()
gp = GraphProperties()
ir = [t.inforatio()[0] for t in tsd_list]
# if we have too many combinations remove legend and use scaled shaded colour
# if len(port_list) > 10:
# gp.color = 'Blues'
# gp.display_legend = False
# plot all the variations
gp.resample = 'B'
gp.file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' ' + parameter_type + '.png'
gp.html_file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' ' + parameter_type + '.html'
gp.scale_factor = self.SCALE_FACTOR
gp.title = strat.FINAL_STRATEGY + ' ' + parameter_type
pf.plot_line_graph(port_list, adapter = self.DEFAULT_PLOT_ENGINE, gp = gp)
# plot all the IR in a bar chart form (can be easier to read!)
gp = GraphProperties()
gp.file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' ' + parameter_type + ' IR.png'
gp.html_file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' ' + parameter_type + ' IR.html'
gp.scale_factor = self.SCALE_FACTOR
gp.title = strat.FINAL_STRATEGY + ' ' + parameter_type
summary = pandas.DataFrame(index = pretty_portfolio_names, data = ir, columns = ['IR'])
pf.plot_bar_graph(summary, adapter = self.DEFAULT_PLOT_ENGINE, gp = gp)
return port_list
'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
if True:
time_series_request = TimeSeriesRequest(
start_date="01 Jan 2015", # start date
finish_date=datetime.date.today(), # finish date
freq='daily', # daily data
data_source='bloomberg', # use Bloomberg as data source
tickers=['AUDJPY', # ticker (Thalesians)
'NZDJPY',
'S&P500'],
# 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) + ' ' +
str(cash_backtest.get_portfolio_pnl_desc()[0])
]
signals = cash_backtest.get_porfolio_signal()
# print the last positions (we could also save as CSV etc.)
print(signals.tail(1))
pf = PlotFactory()
gp = GraphProperties()
gp.title = "Thalesians FX trend strategy"
gp.source = 'Thalesians/BBG (calc with PyThalesians Python library)'
gp.scale_factor = 1
gp.file_output = 'output_data/fx-trend-example.png'
pf.plot_line_graph(port, adapter='pythalesians', gp=gp)
###### backtest simple trend following strategy for FX spot basket
if True:
# for backtest and loading data
from pythalesians.market.requests.backtestrequest import BacktestRequest
from pythalesians.backtest.cash.cashbacktest import CashBacktest
from pythalesians.market.requests.timeseriesrequest import TimeSeriesRequest
from pythalesians.market.loaders.lighttimeseriesfactory import LightTimeSeriesFactory
from pythalesians.util.fxconv import FXConv
from pythalesians.timeseries.calcs.timeseriescalcs import TimeSeriesCalcs
start_date = end.replace(hour=0, minute=0, second=0,
microsecond=0) # Returns a copy
time_series_request = TimeSeriesRequest(
start_date=start_date, # start date
finish_date=datetime.datetime.utcnow(), # finish date
freq='intraday', # intraday data
data_source='bloomberg', # use Bloomberg as data source
tickers=['EURUSD'], # ticker (Thalesians)
fields=['close'], # which fields to download
vendor_tickers=['EURUSD BGN Curncy'], # ticker (Bloomberg)
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.columns = [x.replace('.close', '') for x in df.columns.values]
gp = GraphProperties()
gp.title = 'EURUSD stuff!'
gp.file_output = 'EURUSD.png'
gp.source = 'Thalesians/BBG (created with PyThalesians Python library)'
pf = PlotFactory()
pf.plot_line_graph(df, adapter='pythalesians', gp=gp)
pytwitter.update_status("check out my plot of EUR/USD!",
picture=gp.file_output)
from pythalesians.market.loaders.lighttimeseriesfactory import LightTimeSeriesFactory
from pythalesians.market.requests.timeseriesrequest import TimeSeriesRequest
from pythalesians.timeseries.calcs.timeseriescalcs import TimeSeriesCalcs
if True:
import pandas
df = pandas.read_csv("volsurface.csv") # load a snapshot for a vol surface from disk
gp = GraphProperties()
gp.plotly_plot_mode = "offline_html" # render Plotly plot locally (rather than via website)
gp.file_output = "volsurface.png" # save as static PNG file
gp.html_file_output = "volsurface.html" # save as interactive HTML file
gp.title = "GBP/USD vol surface"
gp.color = 'Blues'
# plot surface with Plotly
pf = PlotFactory()
pf.plot_generic_graph(df, type = 'surface', adapter = 'cufflinks', 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
# (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) + ' ' + str(cash_backtest.get_portfolio_pnl_desc()[0])]
signals = cash_backtest.get_porfolio_signal()
# print the last positions (we could also save as CSV etc.)
print(signals.tail(1))
pf = PlotFactory()
gp = GraphProperties()
gp.title = "Thalesians FX trend strategy"
gp.source = 'Thalesians/BBG (calc with PyThalesians Python library)'
gp.scale_factor = 1
gp.file_output = 'output_data/fx-trend-example.png'
pf.plot_line_graph(port, adapter = 'pythalesians', gp = gp)
###### backtest simple trend following strategy for FX spot basket
if True:
# for backtest and loading data
from pythalesians.market.requests.backtestrequest import BacktestRequest
from pythalesians.backtest.cash.cashbacktest import CashBacktest
from pythalesians.market.requests.timeseriesrequest import TimeSeriesRequest
from pythalesians.market.loaders.lighttimeseriesfactory import LightTimeSeriesFactory
from pythalesians.util.fxconv import FXConv
from pythalesians.timeseries.calcs.timeseriescalcs import TimeSeriesCalcs
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:
from datetime import timedelta
ltsf = LightTimeSeriesFactory()
end = datetime.datetime.utcnow()
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)
for cross in ['AUDUSD', 'EURUSD', 'GBPUSD']:
# create total return index using spot + deposits
ind = IndicesFX()
ind_df = ind.create_total_return_index(cross, tenor, spot_df, deposit_df)
ind_df.columns = [x + '.PYT (with carry)' for x in ind_df.columns]
# grab total return index which we downloaded from Bloomberg
bbg_ind_df = tot_df[cross + '.close'].to_frame()
bbg_ind_df.columns = [x + ".BBG (with carry)" for x in bbg_ind_df.columns]
# grab spot data
spot_plot_df = spot_df[cross + '.close'].to_frame()
spot_plot_df = tsc.create_mult_index_from_prices(spot_plot_df)
# combine total return indices (computed by PyThalesians), those from Bloomberg and also spot
# with everything already rebased at 100
ind_df = ind_df.join(bbg_ind_df)
ind_df = ind_df.join(spot_plot_df)
gp = GraphProperties()
gp.title = 'Total return indices in FX & comparing with spot'
gp.scale_factor = 3
pf = PlotFactory()
pf.plot_line_graph(ind_df, adapter = 'pythalesians', gp = gp)
df_event_times.index = df_event_times.index.tz_localize(utc_time) # work in UTC time
from pythalesians.economics.events.eventstudy import EventStudy
es = EventStudy()
# work out cumulative asset price moves moves over the event
df_event = es.get_intraday_moves_over_custom_event(df, df_event_times)
# create an average move
df_event['Avg'] = df_event.mean(axis = 1)
# plotting spot over economic data event
gp = GraphProperties()
gp.scale_factor = 3
gp.title = 'USDJPY spot moves over recent NFP'
# plot in shades of blue (so earlier releases are lighter, later releases are darker)
gp.color = 'Blues'; gp.color_2 = []
gp.y_axis_2_series = []
gp.display_legend = False
# last release will be in red, average move in orange
gp.color_2_series = [df_event.columns[-2], df_event.columns[-1]]
gp.color_2 = ['red', 'orange'] # red, pink
gp.linewidth_2 = 2
gp.linewidth_2_series = gp.color_2_series
pf = PlotFactory()
pf.plot_line_graph(df_event * 100, adapter = 'pythalesians', gp = gp)
from pythalesians.economics.events.eventstudy import EventStudy
es = EventStudy()
# work out cumulative asset price moves moves over the event
df_event = es.get_intraday_moves_over_custom_event(df, df_event_times)
# create an average move
df_event['Avg'] = df_event.mean(axis=1)
# plotting spot over economic data event
gp = GraphProperties()
gp.scale_factor = 3
gp.title = 'USDJPY spot moves over recent NFP'
# plot in shades of blue (so earlier releases are lighter, later releases are darker)
gp.color = 'Blues'
gp.color_2 = []
gp.y_axis_2_series = []
gp.display_legend = False
# last release will be in red, average move in orange
gp.color_2_series = [df_event.columns[-2], df_event.columns[-1]]
gp.color_2 = ['red', 'orange'] # red, pink
gp.linewidth_2 = 2
gp.linewidth_2_series = gp.color_2_series
pf = PlotFactory()
pf.plot_line_graph(df_event * 100, adapter='pythalesians', gp=gp)
time_series_request.vendor_tickers = ['JPINTDUSDJPY']
time_series_request.data_source = 'fred'
df_fred = ltsf.harvest_time_series(time_series_request)
df_fred.columns = [x.replace('.close', '') for x in df_fred.columns.values]
# convert to USD bn
# df_fred = (df_fred * 10000000)
df = df.join(df_fred, how="outer")
df['USDJPY'] = df['USDJPY'].ffill()
# data is in 100 million JPY, divide by 10 to get into 1000 million (ie. 1 billion)
# divide by USD/JPY spot to get into USD
df['USDJPY purchases (bn USD)'] = (df['USDJPY purchases (bn USD)'] / df['USDJPY']) / 10
gp = GraphProperties()
gp.scale_factor = 3
gp.title = "BoJ USDJPY buying"
gp.file_output = "output_data/" + datetime.date.today().strftime("%Y%m%d") + " USDJPY BoJ intervention " \
+ str(gp.scale_factor) + ".png"
gp.source = 'Thalesians/BBG (created with PyThalesians Python library)'
gp.y_axis_2_series = ['USDJPY purchases (bn USD)']
gp.color_2_series = gp.y_axis_2_series
gp.color_2 = ['blue']
pf = PlotFactory()
pf.plot_line_graph(df, adapter = 'pythalesians', gp = gp)
end = datetime.datetime.utcnow()
start_date = end.replace(hour=0, minute=0, second=0, microsecond=0) # Returns a copy
time_series_request = TimeSeriesRequest(
start_date = start_date, # start date
finish_date = datetime.datetime.utcnow(), # finish date
freq = 'intraday', # intraday data
data_source = 'bloomberg', # use Bloomberg as data source
tickers = ['EURUSD'] , # ticker (Thalesians)
fields = ['close'], # which fields to download
vendor_tickers = ['EURUSD BGN Curncy'], # ticker (Bloomberg)
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.columns = [x.replace('.close', '') for x in df.columns.values]
gp = GraphProperties()
gp.title = 'EURUSD stuff!'
gp.file_output = 'EURUSD.png'
gp.source = 'Thalesians/BBG (created with PyThalesians Python library)'
pf = PlotFactory()
pf.plot_line_graph(df, adapter = 'pythalesians', gp = gp)
pytwitter.update_status("check out my plot of EUR/USD!", picture = gp.file_output)
fields = ['close'], # which fields to download
vendor_tickers = vendor_tickers,
vendor_fields = ['close'], # which Bloomberg fields to download
cache_algo = 'internet_load_return') # how to return data
df = ltsf.harvest_time_series(time_series_request)
df.columns = [x.replace('.close', '') for x in df.columns.values]
# Bloomberg does not give the milisecond field when you make a tick request, so might as well downsample to S
df['JPYUSD'] = 1 / df['JPYUSD']
gp = GraphProperties()
pf = PlotFactory()
gp.scale_factor = 3
gp.title = 'FX around last NFP date'
gp.source = 'Thalesians/BBG (created with PyThalesians Python library)'
tsc = TimeSeriesCalcs()
df = tsc.create_mult_index_from_prices(df)
pf.plot_line_graph(df, adapter = 'pythalesians', gp = gp)
###### download tick data from Bloomberg for EUR/USD around last FOMC and then downsample to plot
if True:
finish_date = datetime.datetime.utcnow()
start_date = finish_date - timedelta(days=60)
# fetch Fed times from Bloomberg
time_series_request = TimeSeriesRequest(
start_date = start_date, # start date
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
if True:
time_series_request = TimeSeriesRequest(
start_date="01 Jan 2015", # start date
finish_date=datetime.date.today(), # finish date
freq='daily', # daily data
data_source='bloomberg', # use Bloomberg as data source
tickers=[
'AUDJPY', # ticker (Thalesians)
'NZDJPY',
vendor_tickers = ['SPX Index'], # ticker (Quandl)
vendor_fields = ['PX_LAST'], # 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 = 'S&P500 seasonality'
gp.scale_factor = 3
gp.file_output = "output_data/S&P500 DOM seasonality.png"
pf.plot_line_graph(day_of_month_seasonality, adapter='pythalesians', gp = gp)
###### calculate seasonal moves in EUR/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