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 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 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 plot_strategy_group_leverage(self):
pf = PlotFactory()
gp = GraphProperties()
gp = self.create_graph_properties("Leverage", "Group Leverage")
pf.plot_line_graph(self.reduce_plot(self._strategy_group_leverage), adapter = self.DEFAULT_PLOT_ENGINE, gp = gp)
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 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 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_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 plot_2d_graph(self, data_frame, gp, chart_type):
sns.set()
if gp is None: gp = GraphProperties()
if gp.chart_type is None and chart_type is None: chart_type = 'line'
if gp.resample is not None: data_frame = data_frame.asfreq(gp.resample)
self.apply_style_sheet(gp)
if chart_type == 'heatmap':
# Draw a heatmap with the numeric values in each cell
sns_plot = sns.heatmap(data_frame,
annot=True,
fmt="d",
linewidths=.5)
fig = sns_plot.fig
# TODO
pass
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 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 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)
freq = 'second', # second data
data_source = 'bloomberg', # use Bloomberg as data source
tickers = tickers, # ticker (Thalesians)
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)
import datetime
from chartesians.graphs.graphproperties import GraphProperties
from chartesians.graphs.plotfactory import PlotFactory
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
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
# data_type = 'Total Personal Income'; title = 'Total Personal Income'; freq = 12
# data_type = 'House Price Index'; title = 'House Price Index (YoY change %)'; yoy_ret = True; freq = 12;
source = 'fred'
df = hist.get_economic_data_history(start_date, finish_date, country_group, data_type, source=source)
df = df.fillna(method='pad')
if yoy_ret is True: df = 100 * (df / df.shift(freq) - 1)
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
# 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) + ' ' + 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
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
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)
def plot_2d_graph(self, data_frame, gp, chart_type):
if gp is None: gp = GraphProperties()
if gp.chart_type is None and chart_type is None: chart_type = 'line'
scale_factor = gp.scale_factor
try:
if gp.bokeh_plot_mode == "offline_jupyter":
from bokeh.io import output_notebook
output_notebook()
except:
pass
try:
html = gp.html_file_output
if (html is None):
html = "bokeh.htm"
output_file(html)
except:
pass
bar_ind = numpy.arange(1, len(data_frame.index) + 1)
xd, bar_ind, has_bar, no_of_bars = self.get_bar_indices(
data_frame, gp, chart_type, bar_ind)
if type(data_frame.index) == pandas.tslib.Timestamp:
p1 = figure(x_axis_type="datetime",
plot_width=int(gp.width * scale_factor),
plot_height=int(gp.height * scale_factor),
x_range=(xd[0], xd[-1]))
# if has a bar than categorical axis
elif has_bar == True:
p1 = figure(plot_width=int(gp.width * scale_factor),
plot_height=int(gp.height * scale_factor),
x_range=[str(x) for x in data_frame.index])
from math import pi
p1.xaxis.major_label_orientation = pi / 2
# otherwise numerical axis
else:
p1 = figure(plot_width=int(gp.width * scale_factor),
plot_height=int(gp.height * scale_factor),
x_range=(xd[0], xd[-1]))
# set the fonts
p1.axis.major_label_text_font_size = str(10 * scale_factor) + "pt"
p1.axis.major_label_text_font = Constants().bokeh_font
p1.axis.major_label_text_font_style = Constants().bokeh_font_style
p1.xaxis.axis_label_text_font_size = str(10 * scale_factor) + "pt"
p1.xaxis.axis_label_text_font = Constants().bokeh_font
p1.xaxis.axis_label_text_font_style = Constants().bokeh_font_style
p1.xaxis.axis_label = gp.x_title
p1.yaxis.axis_label_text_font_size = str(10 * scale_factor) + "pt"
p1.yaxis.axis_label_text_font = Constants().bokeh_font
p1.yaxis.axis_label_text_font_style = Constants().bokeh_font_style
p1.yaxis.axis_label = gp.y_title
p1.legend.label_text_font_size = str(10 * scale_factor) + "pt"
p1.legend.label_text_font = Constants().bokeh_font
p1.legend.label_text_font_style = Constants().bokeh_font_style
p1.legend.fill_alpha = 0
# set chart outline
p1.outline_line_width = 0
p1.title_text_font_size = str(14 * scale_factor) + "pt"
p1.title_text_font = Constants().bokeh_font
# TODO fix label
# if gp.display_source_label:
# p1.text([30 * scale_factor, 30 * scale_factor], [0, 0], text = [gp.brand_label],
# text_font_size = str(10 * scale_factor) + "pt", text_align = "left",
# text_font = Constants().bokeh_font)
color_spec = self.create_color_list(gp, data_frame)
import matplotlib
bar_space = 0.2
bar_width = (1 - bar_space) / (no_of_bars)
bar_index = 0
has_bar = False
# plot each series in the dataframe separately
for i in range(0, len(data_frame.columns)):
label = str(data_frame.columns[i])
glyph_name = 'glpyh' + str(i)
# set chart type which can differ for each time series
if chart_type is not None:
if gp.chart_type is not None:
if isinstance(gp.chart_type, list):
chart_type = gp.chart_type[i]
else:
chart_type = gp.chart_type
# get the color
if color_spec[i] is None:
color_spec[i] = self.get_color_list(i)
try:
color_spec[i] = matplotlib.colors.rgb2hex(color_spec[i])
except:
pass
yd = data_frame.ix[:, i]
# plot each time series as appropriate line, scatter etc.
if chart_type == 'line':
linewidth_t = self.get_linewidth(label, gp.linewidth,
gp.linewidth_2,
gp.linewidth_2_series)
if linewidth_t is None: linewidth_t = 1
if gp.display_legend:
p1.line(
xd,
yd,
color=color_spec[i],
line_width=linewidth_t,
name=glyph_name,
legend=label,
)
else:
p1.line(xd,
data_frame.ix[:, i],
color=color_spec[i],
line_width=linewidth_t,
name=glyph_name)
elif (chart_type == 'bar'):
bar_pos = [
k - (1 - bar_space) / 2. + bar_index * bar_width
for k in range(1,
len(bar_ind) + 1)
]
bar_pos_right = [x + bar_width for x in bar_pos]
if gp.display_legend:
p1.quad(top=yd,
bottom=0 * yd,
left=bar_pos,
right=bar_pos_right,
color=color_spec[i],
legend=label)
else:
p1.quad(top=yd,
bottom=0 * yd,
left=bar_pos,
right=bar_pos_right,
color=color_spec[i])
bar_index = bar_index + 1
bar_ind = bar_ind + bar_width
elif chart_type == 'scatter':
linewidth_t = self.get_linewidth(label, gp.linewidth,
gp.linewidth_2,
gp.linewidth_2_series)
if linewidth_t is None: linewidth_t = 1
if gp.display_legend:
p1.circle(
xd,
yd,
color=color_spec[i],
line_width=linewidth_t,
name=glyph_name,
legend=label,
)
else:
p1.circle(xd,
yd,
color=color_spec[i],
line_width=linewidth_t,
name=glyph_name)
# set common properties
# glyph = p1.select(name=glyph_name)[0].glyph
try:
p1.title = gp.title
except:
pass
p1.grid.grid_line_alpha = 0.3
show(p1) # open a browser
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)
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 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
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
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',
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)
import datetime
from chartesians.graphs.graphproperties import GraphProperties
from chartesians.graphs.plotfactory import PlotFactory
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
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)
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
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
freq='second', # second data
data_source='bloomberg', # use Bloomberg as data source
tickers=tickers, # ticker (Thalesians)
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)
def plot_2d_graph(self, data_frame, gp, chart_type):
mode = 'line'
if gp is None: gp = GraphProperties()
if gp.chart_type is None:
if chart_type is None: chart_type = 'line'
else:
chart_type = gp.chart_type
marker_size = 1
x = ''; y = ''; z = ''
fig = None
if chart_type == 'line':
chart_type = 'scatter'
elif chart_type == 'scatter':
mode = 'markers'
marker_size = 5
elif chart_type == 'bubble':
x = data_frame.columns[0]
y = data_frame.columns[1]
z = data_frame.columns[2]
# special case for choropleth which has yet to be implemented in Cufflinks
# will likely remove this in the future
elif chart_type == 'choropleth':
for col in data_frame.columns:
try:
data_frame[col] = data_frame[col].astype(str)
except:
pass
if gp.color != []:
color = gp.color
else:
color = [[0.0, 'rgb(242,240,247)'],[0.2, 'rgb(218,218,235)'],[0.4, 'rgb(188,189,220)'],\
[0.6, 'rgb(158,154,200)'],[0.8, 'rgb(117,107,177)'],[1.0, 'rgb(84,39,143)']]
text = ''
if 'text' in data_frame.columns:
text = data_frame['Text']
data = [ dict(
type='choropleth',
colorscale = color,
autocolorscale = False,
locations = data_frame['Code'],
z = data_frame[gp.plotly_choropleth_field].astype(float),
locationmode = gp.plotly_location_mode,
text = text,
marker = dict(
line = dict (
color = 'rgb(255,255,255)',
width = 1
)
),
colorbar = dict(
title = gp.units
)
) ]
layout = dict(
title = gp.title,
geo = dict(
scope=gp.plotly_scope,
projection=dict( type=gp.plotly_projection ),
showlakes = True,
lakecolor = 'rgb(255, 255, 255)',
),
)
fig = dict( data=data, layout=layout )
scale = 1
try:
if (gp.plotly_plot_mode == 'offline_html'):
scale = 2/3
except:
pass
# check other plots implemented by Cufflinks
if fig is None:
# special case for surface (given coloring)
if chart_type == 'surface':
# create figure
fig = data_frame.iplot(kind=chart_type,
title=gp.title,
xTitle=gp.x_title,
yTitle=gp.y_title,
x=x, y=y, z=z,
mode=mode,
size=marker_size,
theme=gp.plotly_theme,
bestfit=gp.line_of_best_fit,
legend=gp.display_legend,
colorscale=gp.color,
dimensions=(gp.width * gp.scale_factor * scale, gp.height * gp.scale_factor * scale),
asFigure=True)
else:
# get all the correct colors (and construct gradients if necessary eg. from 'Blues')
# need to change to strings for cufflinks
color_spec = []
color_list = self.create_color_list(gp, data_frame)
# if no colors are specified strip the list
if color_list == [None] * len(color_list):
color_spec = None
else:
# otherwise assume all the colors are rgba
for color in color_list:
color = 'rgba' + str(color)
color_spec.append(color)
# create figure
fig = data_frame.iplot(kind=chart_type,
title=gp.title,
xTitle=gp.x_title,
yTitle=gp.y_title,
x=x, y=y, z=z,
mode=mode,
size=marker_size,
theme=gp.plotly_theme,
bestfit=gp.line_of_best_fit,
legend=gp.display_legend,
color=color_spec,
dimensions=(gp.width * gp.scale_factor * scale, gp.height * gp.scale_factor * scale),
asFigure=True)
self.publish_plot(fig, gp)
time_series_request = TimeSeriesRequest(
start_date=start, # start date
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()
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
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
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)
fields=['close'], # which fields to download
vendor_tickers=[
'EURUSD BGN Curncy', # ticker (Bloomberg)
'GBPUSD BGN Curncy',
'JPYUSD BGN Curncy',
'AUDUSD BGN Curncy'
],
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()
pf = PlotFactory()
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 daily data from Quandl (via FRED) for EUR/USD and GBP/USD spot and then plot
if False:
time_series_request = TimeSeriesRequest(
start_date="01 Jan 1970", # start date
finish_date=datetime.date.today(), # finish date
freq='daily', # daily data
tickers = ['S&P500'],
fields = ['close'], # which fields to download
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)
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)
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.get_economic_data_history(start_date,
finish_date,
country_group,
data_type,
source=source)
df = df.fillna(method='pad')
if yoy_ret is True: df = 100 * (df / df.shift(freq) - 1)
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
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 plot_2d_graph(self, data_frame, gp, chart_type):
if gp is None: gp = GraphProperties()
if gp.chart_type is None and chart_type is None: chart_type = 'line'
if gp.resample is not None: data_frame = data_frame.asfreq(gp.resample)
self.apply_style_sheet(gp)
# create figure & add a subplot
fig = plt.figure(figsize=((gp.width * gp.scale_factor) / gp.dpi,
(gp.height * gp.scale_factor) / gp.dpi),
dpi=gp.dpi)
ax = fig.add_subplot(111)
if gp.x_title != '': ax.set_xlabel(gp.x_title)
if gp.y_title != '': ax.set_ylabel(gp.y_title)
plt.xlabel(gp.x_title)
plt.ylabel(gp.y_title)
fig.suptitle(gp.title, fontsize=14 * gp.scale_factor)
# format Y axis
y_formatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
ax.yaxis.set_major_formatter(y_formatter)
# create a second y axis if necessary
ax2 = []
if gp.y_axis_2_series != []:
ax2 = ax.twinx()
# do not use a grid with multiple y axes
ax.yaxis.grid(False)
ax2.yaxis.grid(False)
# matplotlib 1.5
try:
cyc = matplotlib.rcParams['axes.prop_cycle']
color_cycle = [x['color'] for x in cyc]
except KeyError:
# pre 1.5
pass
# color_cycle = matplotlib.rcParams['axes.color_cycle']
bar_ind = np.arange(0, len(data_frame.index))
# for bar charts, create a proxy x-axis (then relabel)
xd, bar_ind, has_bar, no_of_bars = self.get_bar_indices(
data_frame, gp, chart_type, bar_ind)
# plot the lines (using custom palettes as appropriate)
try:
# get all the correct colors (and construct gradients if necessary eg. from 'blues')
color_spec = self.create_color_list(gp, data_frame)
# for stacked bar
yoff_pos = np.zeros(len(data_frame.index.values)
) # the bottom values for stacked bar chart
yoff_neg = np.zeros(len(data_frame.index.values)
) # the bottom values for stacked bar chart
zeros = np.zeros(len(data_frame.index.values))
# for bar chart
bar_space = 0.2
bar_width = (1 - bar_space) / (no_of_bars)
bar_index = 0
has_matrix = False
# some lines we should exclude from the color and use the default palette
for i in range(0, len(data_frame.columns.values)):
if gp.chart_type is not None:
if isinstance(gp.chart_type, list):
chart_type = gp.chart_type[i]
else:
chart_type = gp.chart_type
if chart_type == 'heatmap':
# TODO experimental!
# ax.set_frame_on(False)
ax.pcolor(data_frame, cmap=plt.cm.Blues, alpha=0.8)
# plt.colorbar()
has_matrix = True
break
label = str(data_frame.columns[i])
ax_temp = self.get_axis(ax, ax2, label, gp.y_axis_2_series)
yd = data_frame.ix[:, i]
if color_spec[i] is None:
color_spec[i] = color_cycle[i % len(color_cycle)]
if (chart_type == 'line'):
linewidth_t = self.get_linewidth(label, gp.linewidth,
gp.linewidth_2,
gp.linewidth_2_series)
if linewidth_t is None:
linewidth_t = matplotlib.rcParams['axes.linewidth']
ax_temp.plot(xd,
yd,
label=label,
color=color_spec[i],
linewidth=linewidth_t)
elif (chart_type == 'bar'):
# for multiple bars we need to allocate space properly
bar_pos = [
k - (1 - bar_space) / 2. + bar_index * bar_width
for k in range(0, len(bar_ind))
]
ax_temp.bar(bar_pos,
yd,
bar_width,
label=label,
color=color_spec[i])
bar_index = bar_index + 1
elif (chart_type == 'stacked'):
bar_pos = [
k - (1 - bar_space) / 2. + bar_index * bar_width
for k in range(0, len(bar_ind))
]
yoff = np.where(yd > 0, yoff_pos, yoff_neg)
ax_temp.bar(bar_pos,
yd,
label=label,
color=color_spec[i],
bottom=yoff)
yoff_pos = yoff_pos + np.maximum(yd, zeros)
yoff_neg = yoff_neg + np.minimum(yd, zeros)
# bar_index = bar_index + 1
elif (chart_type == 'scatter'):
ax_temp.scatter(xd, yd, label=label, color=color_spec[i])
if gp.line_of_best_fit is True:
self.trendline(ax_temp,
xd.values,
yd.values,
order=1,
color=color_spec[i],
alpha=1,
scale_factor=gp.scale_factor)
# format X axis
self.format_x_axis(ax, data_frame, gp, has_bar, bar_ind,
has_matrix)
except:
pass
if gp.display_source_label == True:
ax.annotate('Source: ' + gp.source,
xy=(1, 0),
xycoords='axes fraction',
fontsize=7 * gp.scale_factor,
xytext=(-5 * gp.scale_factor, 10 * gp.scale_factor),
textcoords='offset points',
ha='right',
va='top',
color=gp.source_color)
if gp.display_brand_label == True:
self.create_brand_label(ax,
anno=gp.brand_label,
scale_factor=gp.scale_factor)
leg = []
leg2 = []
loc = 'best'
# if we have two y-axis then make sure legends are in opposite corners
if ax2 != []: loc = 2
try:
leg = ax.legend(loc=loc, prop={'size': 10 * gp.scale_factor})
leg.get_frame().set_linewidth(0.0)
leg.get_frame().set_alpha(0)
if ax2 != []:
leg2 = ax2.legend(loc=1, prop={'size': 10 * gp.scale_factor})
leg2.get_frame().set_linewidth(0.0)
leg2.get_frame().set_alpha(0)
except:
pass
try:
if gp.display_legend is False:
if leg != []: leg.remove()
if leg2 != []: leg.remove()
except:
pass
try:
plt.savefig(gp.file_output, transparent=False)
except:
pass
####### various matplotlib converters are unstable
# convert to D3 format with mpld3
try:
# output matplotlib charts externally to D3 based libraries
import mpld3
if gp.display_mpld3 == True:
mpld3.save_d3_html(fig, gp.html_file_output)
mpld3.show(fig)
except:
pass
# FRAGILE! convert to Bokeh format
# better to use direct Bokeh renderer
try:
if (gp.convert_matplotlib_to_bokeh == True):
from bokeh.plotting import output_file, show
from bokeh import mpl
output_file(gp.html_file_output)
show(mpl.to_bokeh())
except:
pass
# FRAGILE! convert matplotlib chart to Plotly format
# recommend using AdapterCufflinks instead to directly plot to Plotly
try:
import plotly.plotly as py
import plotly
import plotly.tools as tls
if gp.convert_matplotlib_to_plotly == True:
plotly.tools.set_credentials_file(username=gp.plotly_username,
api_key=gp.plotly_api_key)
py_fig = tls.mpl_to_plotly(fig, strip_style=True)
plot_url = py.plot_mpl(py_fig, filename=gp.plotly_url)
except:
pass
# display in matplotlib window
try:
if GraphicsConstants.plotfactory_silent_display == True:
return fig
elif gp.silent_display == False:
plt.show()
else:
return fig
except:
pass
],
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)
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:
from datetime import timedelta
ltsf = LightTimeSeriesFactory()
