def plot_strategy_group_benchmark_pnl(self):
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
#gp.color = 'RdYlGn'
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - cumulative).png'
# plot cumulative line of returns
pf.plot_line_graph(self.reduce_plot(self._strategy_group_benchmark_pnl), adapter = 'pythalesians', gp = gp)
# needs write stats flag turned on
try:
keys = self._strategy_group_benchmark_tsd.keys()
ir = []
for key in keys: ir.append(self._strategy_group_benchmark_tsd[key].inforatio()[0])
ret_stats = pandas.DataFrame(index = keys, data = ir, columns = ['IR'])
ret_stats = ret_stats.sort_index()
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - IR).png'
gp.display_brand_label = False
# plot ret stats
pf.plot_bar_graph(ret_stats, adapter = 'pythalesians', gp = gp)
except: pass
def plot_strategy_signal_proportion(self, strip = None):
signal = self._strategy_signal
long = signal[signal > 0].count()
short = signal[signal < 0].count()
flat = signal[signal == 0].count()
keys = long.index
df = pandas.DataFrame(index = keys, columns = ['Long', 'Short', 'Flat'])
df['Long'] = long
df['Short'] = short
df['Flat'] = flat
if strip is not None: keys = [k.replace(strip, '') for k in keys]
df.index = keys
df = df.sort_index()
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy signal proportion).png'
try:
pf.plot_bar_graph(self.reduce_plot(df), adapter = 'pythalesians', gp = gp)
except: pass
def plot_strategy_group_benchmark_pnl(self):
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
#gp.color = 'RdYlGn'
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - cumulative).png'
# plot cumulative line of returns
pf.plot_line_graph(self.reduce_plot(
self._strategy_group_benchmark_pnl),
adapter='pythalesians',
gp=gp)
keys = self._strategy_group_benchmark_tsd.keys()
ir = []
for key in keys:
ir.append(self._strategy_group_benchmark_tsd[key].inforatio()[0])
ret_stats = pandas.DataFrame(index=keys, data=ir, columns=['IR'])
ret_stats = ret_stats.sort()
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - IR).png'
gp.display_brand_label = False
# plot ret stats
pf.plot_bar_graph(ret_stats, adapter='pythalesians', 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 plot_strategy_group_leverage(self):
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY + ' Leverage'
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Leverage).png'
pf.plot_line_graph(self.reduce_plot(self._strategy_group_leverage), adapter = 'pythalesians', gp = gp)
def plot_strategy_group_leverage(self):
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY + ' Leverage'
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Leverage).png'
pf.plot_line_graph(self.reduce_plot(self._strategy_group_leverage), adapter = 'pythalesians', gp = gp)
def plot_individual_leverage(self):
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY + ' Leverage'
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Individual Leverage).png'
try:
pf.plot_line_graph(self.reduce_plot(self._individual_leverage), adapter = 'pythalesians', gp = gp)
except: pass
def plot_strategy_pnl(self):
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy PnL).png'
try:
pf.plot_line_graph(self.reduce_plot(self._strategy_pnl), adapter = 'pythalesians', gp = gp)
except: pass
def plot_strategy_pnl(self):
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy PnL).png'
try:
pf.plot_line_graph(self.reduce_plot(self._strategy_pnl), adapter = 'pythalesians', gp = gp)
except: pass
def plot_individual_leverage(self):
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY + ' Leverage'
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Individual Leverage).png'
try:
pf.plot_line_graph(self.reduce_plot(self._individual_leverage), adapter = 'pythalesians', gp = gp)
except: pass
def plot_strategy_signal_proportion(self, strip=None):
signal = self._strategy_signal
# count number of long, short and flat periods in our sample
long = signal[signal > 0].count()
short = signal[signal < 0].count()
flat = signal[signal == 0].count()
keys = long.index
# how many trades have there been (ignore size of the trades)
trades = abs(signal - signal.shift(-1))
trades = trades[trades > 0].count()
df_trades = pandas.DataFrame(index=keys,
columns=['Trades'],
data=trades)
df = pandas.DataFrame(index=keys, columns=['Long', 'Short', 'Flat'])
df['Long'] = long
df['Short'] = short
df['Flat'] = flat
if strip is not None: keys = [k.replace(strip, '') for k in keys]
df.index = keys
df_trades.index = keys
# df = df.sort_index()
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
try:
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy signal proportion).png'
pf.plot_bar_graph(self.reduce_plot(df),
adapter='pythalesians',
gp=gp)
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy trade no).png'
pf.plot_bar_graph(self.reduce_plot(df_trades),
adapter='pythalesians',
gp=gp)
except:
pass
def plot_strategy_group_benchmark_annualised_pnl(self, cols = None):
# TODO - unfinished, needs checking!
if cols is None: cols = self._strategy_group_benchmark_annualised_pnl.columns
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
gp.color = ['red', 'blue', 'purple', 'gray', 'yellow', 'green', 'pink']
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark Annualised PnL).png'
pf.plot_line_graph(self.reduce_plot(self._strategy_group_benchmark_annualised_pnl[cols]), adapter = 'pythalesians', gp = gp)
def plot_strategy_group_pnl_trades(self):
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY + " (bp)"
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Individual Trade PnL).png'
# zero when there isn't a trade exit
strategy_pnl_trades = self._strategy_pnl_trades.fillna(0) * 100 * 100
try:
pf.plot_line_graph(self.reduce_plot(strategy_pnl_trades), adapter = 'pythalesians', gp = gp)
except: pass
def plot_strategy_group_benchmark_annualised_pnl(self, cols = None):
# TODO - unfinished, needs checking!
if cols is None: cols = self._strategy_group_benchmark_annualised_pnl.columns
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
gp.color = ['red', 'blue', 'purple', 'gray', 'yellow', 'green', 'pink']
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark Annualised PnL).png'
pf.plot_line_graph(self.reduce_plot(self._strategy_group_benchmark_annualised_pnl[cols]), adapter = 'pythalesians', 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 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.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 = 'pythalesians', 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.title = strat.FINAL_STRATEGY + ' month of year seasonality'
pf.plot_line_graph(month, adapter = 'pythalesians', gp = gp)
return month
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')
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')
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.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='pythalesians', 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.title = strat.FINAL_STRATEGY + ' month of year seasonality'
pf.plot_line_graph(month, adapter='pythalesians', gp=gp)
return month
def plot_strategy_group_benchmark_pnl(self, strip=None):
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
#gp.color = 'RdYlGn'
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - cumulative).png'
strat_list = self._strategy_group_benchmark_pnl.columns.sort_values()
for line in strat_list:
self.logger.info(line)
# plot cumulative line of returns
pf.plot_line_graph(self.reduce_plot(
self._strategy_group_benchmark_pnl),
adapter='pythalesians',
gp=gp)
# needs write stats flag turned on
try:
keys = self._strategy_group_benchmark_tsd.keys()
ir = []
for key in keys:
ir.append(
self._strategy_group_benchmark_tsd[key].inforatio()[0])
if strip is not None: keys = [k.replace(strip, '') for k in keys]
ret_stats = pandas.DataFrame(index=keys, data=ir, columns=['IR'])
ret_stats = ret_stats.sort_index()
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - IR).png'
gp.display_brand_label = False
# plot ret stats
pf.plot_bar_graph(ret_stats, adapter='pythalesians', gp=gp)
except:
pass
def plot_strategy_signal_proportion(self, strip = None):
signal = self._strategy_signal
# count number of long, short and flat periods in our sample
long = signal[signal > 0].count()
short = signal[signal < 0].count()
flat = signal[signal == 0].count()
keys = long.index
# how many trades have there been (ignore size of the trades)
trades = abs(signal - signal.shift(-1))
trades = trades[trades > 0].count()
df_trades = pandas.DataFrame(index = keys, columns = ['Trades'], data = trades)
df = pandas.DataFrame(index = keys, columns = ['Long', 'Short', 'Flat'])
df['Long'] = long
df['Short'] = short
df['Flat'] = flat
if strip is not None: keys = [k.replace(strip, '') for k in keys]
df.index = keys
df_trades.index = keys
# df = df.sort_index()
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
try:
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy signal proportion).png'
pf.plot_bar_graph(self.reduce_plot(df), adapter = 'pythalesians', gp = gp)
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy trade no).png'
pf.plot_bar_graph(self.reduce_plot(df_trades), adapter = 'pythalesians', gp = gp)
except: pass
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):
stats_df = self.report_single_var_regression(y, x, y_variable_names,
x_variable_names,
statistic, pretty_index)
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 + ').png'
pf.plot_bar_graph(stats_df, adapter='pythalesians', gp=gp)
return stats_df
def plot_strategy_signal_proportion(self, strip=None):
signal = self._strategy_signal
long = signal[signal > 0].count()
short = signal[signal < 0].count()
flat = signal[signal == 0].count()
keys = long.index
df = pandas.DataFrame(index=keys, columns=['Long', 'Short', 'Flat'])
df['Long'] = long
df['Short'] = short
df['Flat'] = flat
if strip is not None: keys = [k.replace(strip, '') for k in keys]
df.index = keys
df = df.sort_index()
pf = PlotFactory()
gp = GraphProperties()
gp.title = self.FINAL_STRATEGY
gp.display_legend = True
gp.scale_factor = self.SCALE_FACTOR
gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy signal proportion).png'
try:
pf.plot_bar_graph(self.reduce_plot(df),
adapter='pythalesians',
gp=gp)
except:
pass
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 = "apple.htm"
gp.title = "S&P500 vs Apple"
# plot first with PyThalesians and then Plotly (via Cufflinks)
# just needs 1 word to change
# (although, note that AdapterCufflinks does have some extra parameters that can be set in
# GraphProperties)
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)
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()
start = end - timedelta(days=180)
tickers = ['S&P500', 'FTSE', 'Nikkei']
vendor_tickers = ['SPX Index', 'UKX Index', 'NKY Index']
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. # In[ ]: get_ipython().magic(u'matplotlib inline') from pythalesians.graphics.graphs.plotfactory import PlotFactory from pythalesians.graphics.graphs.graphproperties import GraphProperties gp = GraphProperties() gp.source = 'Thalesians/BBG (created with PyThalesians Python library)' gp.title = 'Equity Markets' gp.scale_factor = 1 gp.display_legend = True gp.x_title = 'Dates' gp.y_title = 'Index' pf = PlotFactory() pf.plot_line_graph(df, adapter = 'pythalesians', gp = gp) # In[ ]:
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()
start = end - timedelta(days=180)
tickers = ['S&P500', 'FTSE', 'Nikkei']
vendor_tickers = ['SPX Index', 'UKX Index', 'NKY Index']
import pandas
df.columns = [x.replace('.close', '') for x in df.columns.values]
short_dates = df[["EURUSDV1M", "USDJPYV1M"]]
long_dates = df[["EURUSDV1Y", "USDJPYV1Y"]]
short_dates, long_dates = short_dates.align(long_dates, join='left', axis = 0)
slope = pandas.DataFrame(data = short_dates.values - long_dates.values, index = short_dates.index,
columns = ["EURUSDV1M-1Y", "USDJPYV1M-1Y"])
# resample fand calculate average over month
slope_monthly = slope.resample('M', how='mean')
slope_monthly.index = [str(x.year) + '/' + str(x.month) for x in slope_monthly.index]
pf = PlotFactory()
gp = GraphProperties()
gp.source = 'Thalesians/BBG'
gp.title = 'Vol slopes in EUR/USD and USD/JPY recently'
gp.scale_factor = 2
gp.display_legend = True
gp.chart_type = 'bar'
gp.x_title = 'Dates'
gp.y_title = 'Pc'
# plot using Cufflinks
pf.plot_bar_graph(slope_monthly, adapter = 'bokeh', 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)
