def __init__(self,
engine='plotly',
data_source='bloomberg',
market_data_generator=MarketDataGenerator()):
self._chart = Chart(engine=engine)
self._market = Market(market_data_generator=market_data_generator)
self._data_source = data_source
def plot_animated_vol_market():
market = Market(market_data_generator=MarketDataGenerator())
cross = ['EURUSD']; start_date = '01 Mar 2017'; finish_date = '21 Apr 2017'; sampling = 'no'
md_request = MarketDataRequest(start_date=start_date, finish_date=finish_date,
data_source='bloomberg', cut='NYC', category='fx-implied-vol',
tickers=cross, cache_algo='cache_algo_return')
df = market.fetch_market(md_request)
if sampling != 'no': df = df.resample(sampling).mean()
fxvf = FXVolFactory()
df_vs = []
# Grab the vol surface for each date and create a dataframe for each date (could have used a panel)
for i in range(0, len(df.index)): df_vs.append(fxvf.extract_vol_surface_for_date(df, cross[0], i))
# Do static plot for first day using Plotly
style = Style(title="FX vol surface of " + cross[0], source="chartpy", color='Blues')
Chart(df=df_vs[0], chart_type='surface', style=style).plot(engine='plotly')
# Now do animation (TODO: need to fix animation in chartpy for matplotlib)
style = Style(title="FX vol surface of " + cross[0], source="chartpy", color='Blues',
animate_figure=True, animate_titles=df.index,
animate_frame_ms=500, normalize_colormap=False)
Chart(df=df_vs, chart_type='surface', style=style).plot(engine='plotly')
# Chart object is initialised with the dataframe and our chart style
Chart(df=df_vs, chart_type='surface', style=style).plot(engine='plotly')
def plot_strategy_group_benchmark_pnl_yoy(self, strip = None, silent_plot = False):
style = self.create_style("", "Group Benchmark PnL YoY - cumulative")
keys = self._strategy_group_benchmark_ret_stats.keys()
yoy = []
for key in keys:
col = self._strategy_group_benchmark_ret_stats[key].yoy_rets()
col.columns = [key]
yoy.append(col)
calculations = Calculations()
ret_stats = calculations.pandas_outer_join(yoy)
ret_stats.index = ret_stats.index.year
if strip is not None: ret_stats.columns = [k.replace(strip, '') for k in ret_stats.columns]
# ret_stats = ret_stats.sort_index()
style.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - YoY) ' + str(style.scale_factor) + '.png'
style.html_file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - YoY) ' + str(style.scale_factor) + '.html'
style.display_brand_label = False
style.date_formatter = "%Y"
chart = Chart(ret_stats * 100, engine=self.DEFAULT_PLOT_ENGINE, chart_type='bar', style=style)
if not (silent_plot): chart.plot()
return chart
def plot_strategy_group_benchmark_pnl_yoy(self, strip = None, silent_plot = False):
style = self.create_style("", "Group Benchmark PnL YoY - cumulative")
keys = self._strategy_group_benchmark_ret_stats.keys()
yoy = []
for key in keys:
col = self._strategy_group_benchmark_ret_stats[key].yoy_rets()
col.columns = [key]
yoy.append(col)
calculations = Calculations()
ret_stats = calculations.pandas_outer_join(yoy)
ret_stats.index = ret_stats.index.year
if strip is not None: ret_stats.columns = [k.replace(strip, '') for k in ret_stats.columns]
# ret_stats = ret_stats.sort_index()
style.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - YoY) ' + str(style.scale_factor) + '.png'
style.html_file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - YoY) ' + str(style.scale_factor) + '.html'
style.display_brand_label = False
style.date_formatter = "%Y"
chart = Chart(ret_stats * 100, engine=self.DEFAULT_PLOT_ENGINE, chart_type='bar', style=style)
if not (silent_plot): chart.plot()
return chart
def plot_strategy_group_benchmark_pnl_ir(self,
strip=None,
silent_plot=False):
style = self.create_style("", "Group Benchmark PnL IR - cumulative")
keys = self._strategy_group_benchmark_ret_stats.keys()
ir = []
for key in keys:
ir.append(
self._strategy_group_benchmark_ret_stats[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()
style.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - IR) ' + str(
style.scale_factor) + '.png'
style.html_file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - IR) ' + str(
style.scale_factor) + '.html'
style.display_brand_label = False
chart = Chart(ret_stats,
engine=self.DEFAULT_PLOT_ENGINE,
chart_type='bar',
style=style)
if not (silent_plot): chart.plot()
return chart
def __init__(self, engine=ChartConstants().chartfactory_default_engine):
# self.logger = LoggerManager().getLogger(__name__)
self.DUMP_PATH = 'output_data/' + datetime.date.today().strftime("%Y%m%d") + ' '
self.DEFAULT_PLOT_ENGINE = engine
self.chart = Chart(engine=self.DEFAULT_PLOT_ENGINE)
return
def plot_strategy_trade_no(self, strip=None, silent_plot=False):
signal = self._strategy_signal
####### 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=trades.index,
columns=['Trades'],
data=trades)
if strip is not None:
df_trades.index = [k.replace(strip, '') for k in df_trades.index]
style = self.create_style("", "")
try:
style.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy trade no).png'
style.html_file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy trade no).html'
chart = Chart(self.reduce_plot(df_trades),
engine=self.DEFAULT_PLOT_ENGINE,
chart_type='bar',
style=style)
if not (silent_plot): chart.plot()
return chart
except:
pass
def plot_sharpe(self, silent_plot=False, reduce_plot=True):
"""
Plots the sharpe ratio of the model
Returns the created Chart
Parameters
---------
silent_plot
if you want to only return the chart created
reduce_plot:
when plotting many points use WebGl version of plotly if specified
"""
#sharpe does not take into account risk free rate for simplicity
style = self.models[self.ref_index]._create_style(
"", "Sharpe Curve", reduce_plot=reduce_plot)
models = self.models
ref = self.ref_index
returns = [model._strategy_pnl.pct_change() for model in models]
stdev_of_returns = np.std(returns)
annualized_sharpe = returns / stdev_of_returns * np.sqrt(250)
df = pd.concat(annualized_sharpe, axis=1)
chart = Chart(df,
engine=self.DEFAULT_PLOT_ENGINE,
chart_type='bar',
style=style)
if not silent_plot:
chart.plot()
return chart
def plot_strategy_group_leverage(self, silent_plot = False):
style = self.create_style("Leverage", "Group Leverage")
chart = Chart(self.reduce_plot(self._strategy_group_leverage), engine=self.DEFAULT_PLOT_ENGINE, chart_type='line', style=style)
if not (silent_plot): chart.plot()
return chart
def plot_strategy_signal_proportion(self, strip = None, silent_plot = False):
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()
df = pandas.DataFrame(index = long.index, columns = ['Long', 'Short', 'Flat'])
df['Long'] = long
df['Short'] = short
df['Flat'] = flat
if strip is not None: df.index = [k.replace(strip, '') for k in df.index]
style = self.create_style("", "")
try:
style.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy signal proportion).png'
style.html_file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy signal proportion).html'
chart = Chart(self.reduce_plot(df), engine=self.DEFAULT_PLOT_ENGINE, chart_type='bar', style=style)
if not(silent_plot): chart.plot()
return chart
except: pass
def plot_strategy_trade_notional(self,
diff=True,
silent_plot=False,
reduce_plot=True):
style = self.models[self.ref_index]._create_style(
"", "Trades (Scaled by Notional)", reduce_plot=reduce_plot)
models = self.models
ref = self.ref_index
strategy_trade_notional = [
model._strategy_trade_notional for model in models
]
df = pd.concat(strategy_trade_notional, axis=1)
if diff:
df = df.subtract(strategy_trade_notional[ref], axis='index')
if self.labels is not None:
df.columns = self.labels
chart = Chart(df,
engine=self.DEFAULT_PLOT_ENGINE,
chart_type='bar',
style=style)
if not silent_plot:
chart.plot()
return chart
def plot_strategy_signal_proportion(self, strip = None, silent_plot = False):
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()
df = pandas.DataFrame(index = long.index, columns = ['Long', 'Short', 'Flat'])
df['Long'] = long
df['Short'] = short
df['Flat'] = flat
if strip is not None: df.index = [k.replace(strip, '') for k in df.index]
style = self.create_style("", "")
try:
style.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy signal proportion).png'
style.html_file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy signal proportion).html'
chart = Chart(self.reduce_plot(df), engine=self.DEFAULT_PLOT_ENGINE, chart_type='bar', style=style)
if not(silent_plot): chart.plot()
return chart
except: pass
def plot_strategy_group_leverage(self, silent_plot = False):
style = self.create_style("Leverage", "Group Leverage")
chart = Chart(self.reduce_plot(self._strategy_group_leverage), engine=self.DEFAULT_PLOT_ENGINE, chart_type='line', style=style)
if not (silent_plot): chart.plot()
return chart
def plot_strategy_signals(self, date = None, strip = None, silent_plot = False):
######## plot signals
strategy_signal = self._strategy_signal
strategy_signal = 100 * (strategy_signal)
if date is None:
last_day = strategy_signal.ix[-1].transpose().to_frame()
else:
if not(isinstance(date, list)):
date = [date]
last_day = []
for d in date:
last_day.append(strategy_signal.ix[d].transpose().to_frame())
last_day = pandas.concat(last_day, axis=1)
last_day = last_day.sort_index(axis=1)
if strip is not None:
last_day.index = [x.replace(strip, '') for x in last_day.index]
style = self.create_style("positions (% portfolio notional)", "Positions")
chart = Chart(last_day, engine=self.DEFAULT_PLOT_ENGINE, chart_type='bar', style=style)
if not (silent_plot): chart.plot()
return chart
def __init__(self,
computation_results,
title='Cuemacro Computation',
renderer=CanvasRenderer(),
chart_report_height=constants.chart_report_height,
chart_report_width=constants.chart_report_width):
"""Initialize class, with the computation results we wish to convert into a report like format
Parameters
----------
computation_results : ComputationResults
The results of a large scale computation, which contains charts and DataFrames
title : str
Title of webpage to be rendered
"""
self._util_func = UtilFunc()
self._computation_results = computation_results
self._title = title
self._chart = Chart(engine='plotly')
self._renderer = renderer
self._computation_request = computation_results.computation_request
self._chart_report_width = chart_report_width
self._chart_report_height = chart_report_height
def example_request_mid_benchmark():
"""Example of how to do a calculation to do market analysis to calculate mid, resample etc. without any trade data
"""
from tcapy.analysis.algos.benchmark import BenchmarkMarketMid, BenchmarkMarketSpreadToMid, BenchmarkMarketResampleOffset, \
BenchmarkMarketFilter
from tcapy.analysis.algos.resultsform import BarResultsForm, TimelineResultsForm
tca_request = get_tca_request()
# Allow analysis to be done in a parallel approach day by day
# (note: can't do analysis which requires data outside of the daily chunks to do this!)
tca_request.multithreading_params['splice_request_by_dates'] = use_multithreading
# Filter market data by time of day between 15:00-17:00 LDN
# Then calculate the market mid, then calculate the spread to the mid,
# Then resample the data into 1 minute, taking the mean of each minute (and TWAP) and calculating the absolute range
tca_request.benchmark_calcs = [BenchmarkMarketFilter(time_of_day={'start_time' : "15:00", 'finish_time' : "17:00"},
time_zone='Europe/London'),
BenchmarkMarketMid(), BenchmarkMarketSpreadToMid(),
BenchmarkMarketResampleOffset(market_resample_freq='1', market_resample_unit='min',
price_field='mid', resample_how=['mean', 'twap', 'absrange'], dropna=True),
]
# Calculate the mean spread to mid for EURUSD by time of day during our sample (do not weight by any other field)
# Calculate the mean absrange for EURUSD by time of day (London timezone)/month of _year (ie. proxy for volatility)
tca_request.results_form = \
[TimelineResultsForm(market_trade_order_list='EURUSD', metric_name='ask_mid_spread',
weighting_field=None, by_date='time', scalar=10000.0),
TimelineResultsForm(market_trade_order_list='EURUSD', metric_name='absrange',
weighting_field=None, by_date=['month', 'timeldn'], scalar=10000.0)
]
# return
tca_request.use_multithreading = True
tca_engine = TCAEngineImpl()
dict_of_df = tca_engine.calculate_tca(tca_request)
# Print out all keys for all the DataFrames returned
print(dict_of_df.keys())
# Print market data snapshots
print(dict_of_df['EURUSD_df'])
print(dict_of_df['USDJPY_df'])
print(dict_of_df['EURUSD_df'].columns)
print(dict_of_df['USDJPY_df'].columns)
# Print out mean spread by time of day
print(dict_of_df['timeline_EURUSD_ask_mid_spread_by/mean_time/all'])
# Plot mean spread by time of day and absrange by time of day (in London timezone)
Chart(engine='plotly').plot(dict_of_df['timeline_EURUSD_ask_mid_spread_by/mean_time/all'])
# Plot absolute range over each minute, averaged by time of day and month of the _year
Chart(engine='plotly').plot(dict_of_df['timeline_EURUSD_absrange_by/mean_month_timeldn/all'],
style=Style(title='EURUSD absolute range by time of day (LDN)', color='Reds', scale_factor=-1))
def dataframe_tca_example():
"""Example for doing detailed TCA analysis on all the trades in a CSV, calculating metrics for slippage,
transient market impact & permanent market impact. It also calculates benchmarks for arrival price of each trade and
spread to mid).
Collects results for slippage into a daily timeline and also average by venue (by default weights by reporting
currency)
"""
PLOT = False
# clear entire cache
# Mediator.get_volatile_cache(version='pro').clear_cache()
tca_engine = TCAEngineImpl(version=tca_version)
trade_order_type = 'trade_df'
trade_order_list = ['trade_df']
trade_df = DatabaseSourceCSV(trade_data_database_csv=csv_trade_order_mapping['trade_df']).fetch_trade_order_data()
data_frame_trade_order_mapping = OrderedDict([('trade_df', trade_df)])
start_date = trade_df.index[0]; finish_date = trade_df.index[-1]
ticker_list = FXConv().correct_unique_notation_list(trade_df['ticker'].unique().tolist())
# Specify the TCA request
tca_request = TCARequest(start_date=start_date, finish_date=finish_date, ticker=ticker_list,
tca_type='aggregated', dummy_market=True,
trade_data_store='dataframe', market_data_store=market_data_store,
metric_calcs=[MetricSlippage(trade_order_list=trade_order_list),
MetricTransientMarketImpact(transient_market_impact_gap={'ms': 100},
trade_order_list=trade_order_list),
MetricPermanentMarketImpact(permanent_market_impact_gap={'h': 1},
trade_order_list=trade_order_list)],
results_form=[TimelineResultsForm(metric_name='slippage', by_date='date'),
BarResultsForm(metric_name='slippage', aggregate_by_field='venue')],
benchmark_calcs=[BenchmarkArrival(), BenchmarkSpreadToMid()],
trade_order_mapping=data_frame_trade_order_mapping, use_multithreading=False)
# Dictionary of dataframes as output from TCA calculation
dict_of_df = tca_engine.calculate_tca(tca_request)
print(dict_of_df.keys())
timeline_df = dict_of_df['timeline_' + trade_order_type + '_slippage_by_all'] # average slippage per day
metric_df = dict_of_df[trade_order_type]['permanent_market_impact'] # permanent market impact for every trade
print(metric_df.head(500))
if PLOT:
from chartpy import Chart, Style
# plot slippage by timeline
Chart(engine='plotly').plot(timeline_df)
# plot market impact (per trade)
Chart(engine='plotly').plot(metric_df.head(500))
def plot_strategy_pnl(self, silent_plot = False):
style = self.create_style("", "Strategy PnL")
try:
chart = Chart(self.reduce_plot(self._strategy_pnl), engine=self.DEFAULT_PLOT_ENGINE, chart_type='line', style=style)
if not(silent_plot): chart.plot()
return chart
except: pass
def plot_individual_leverage(self, silent_plot=False):
style = self.create_style("Leverage", "Individual Leverage")
try:
chart = Chart(self.reduce_plot(self._individual_leverage), engine=self.DEFAULT_PLOT_ENGINE, chart_type='line', style=style)
if not(silent_plot): chart.plot()
return chart
except: pass
def plot_strategy_pnl(self, silent_plot = False):
style = self.create_style("", "Strategy PnL")
try:
chart = Chart(self.reduce_plot(self._strategy_pnl), engine=self.DEFAULT_PLOT_ENGINE, chart_type='line', style=style)
if not(silent_plot): chart.plot()
return chart
except: pass
def plot_individual_leverage(self, silent_plot=False):
style = self.create_style("Leverage", "Individual Leverage")
try:
chart = Chart(self.reduce_plot(self._individual_leverage), engine=self.DEFAULT_PLOT_ENGINE, chart_type='line', style=style)
if not(silent_plot): chart.plot()
return chart
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=None,
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
chart = Chart()
style = Style()
if title is None: title = statistic
style.title = title
style.display_legend = True
style.scale_factor = scale_factor
# style.color = ['red', 'blue', 'purple', 'gray', 'yellow', 'green', 'pink']
if output_path is not None:
style.file_output = output_path + ' (' + tag + ' ' + st + ').png'
chart.plot(stats_df, style=style)
return stats_df
def _plot_signal(self, sig, label = ' ', caption = '', date = None, strip = None, silent_plot = False):
######## plot signals
strategy_signal = 100 * (sig)
last_day = self.grab_signals(strategy_signal, date=date, strip=strip)
style = self.create_style(label, caption)
chart = Chart(last_day, engine=self.DEFAULT_PLOT_ENGINE, chart_type='bar', style=style)
if not (silent_plot): chart.plot()
return chart
def plot_strategy_group_benchmark_annualised_pnl(self, cols = None, silent_plot = False):
# TODO - unfinished, needs checking!
if cols is None: cols = self._strategy_group_benchmark_annualised_pnl.columns
style = self.create_style("", "Group Benchmark Annualised PnL")
style.color = ['red', 'blue', 'purple', 'gray', 'yellow', 'green', 'pink']
chart = Chart(self.reduce_plot(self._strategy_group_benchmark_annualised_pnl[cols]), engine=self.DEFAULT_PLOT_ENGINE, chart_type='line', style=style)
if not (silent_plot): chart.plot()
return chart
def _plot_signal(self, sig, label = ' ', caption = '', date = None, strip = None, silent_plot = False):
######## plot signals
strategy_signal = 100 * (sig)
last_day = self.grab_signals(strategy_signal, date=date, strip=strip)
style = self.create_style(label, caption)
chart = Chart(last_day, engine=self.DEFAULT_PLOT_ENGINE, chart_type='bar', style=style)
if not (silent_plot): chart.plot()
return chart
def plot_strategy_group_benchmark_annualised_pnl(self, cols = None, silent_plot = False):
# TODO - unfinished, needs checking!
if cols is None: cols = self._strategy_group_benchmark_annualised_pnl.columns
style = self.create_style("", "Group Benchmark Annualised PnL")
style.color = ['red', 'blue', 'purple', 'gray', 'yellow', 'green', 'pink']
chart = Chart(self.reduce_plot(self._strategy_group_benchmark_annualised_pnl[cols]), engine=self.DEFAULT_PLOT_ENGINE, chart_type='line', style=style)
if not (silent_plot): chart.plot()
return chart
def plot_strategy_group_benchmark_pnl(self, silent_plot = False):
style = self.create_style("", "Group Benchmark PnL - cumulative")
strat_list = self._strategy_group_benchmark_pnl.columns #.sort_values()
for line in strat_list:
self.logger.info(line)
# plot cumulative line of returns
chart = Chart(self.reduce_plot(self._strategy_group_benchmark_pnl), engine=self.DEFAULT_PLOT_ENGINE, chart_type='line',
style=style)
if not (silent_plot): chart.plot()
return chart
def plot_strategy_group_benchmark_pnl(self, silent_plot = False):
style = self.create_style("", "Group Benchmark PnL - cumulative")
strat_list = self._strategy_group_benchmark_pnl.columns #.sort_values()
for line in strat_list:
self.logger.info(line)
# plot cumulative line of returns
chart = Chart(self.reduce_plot(self._strategy_group_benchmark_pnl), engine=self.DEFAULT_PLOT_ENGINE, chart_type='line',
style=style)
if not (silent_plot): chart.plot()
return chart
def plot_strategy_group_pnl_trades(self, silent_plot = False):
style = self.create_style("(bp)", "Individual Trade PnL")
# zero when there isn't a trade exit
# strategy_pnl_trades = self._strategy_pnl_trades * 100 * 100
# strategy_pnl_trades = strategy_pnl_trades.dropna()
# note only works with single large basket trade
try:
strategy_pnl_trades = self._strategy_pnl_trades.fillna(0) * 100 * 100
chart = Chart(self.reduce_plot(strategy_pnl_trades), engine=self.DEFAULT_PLOT_ENGINE, chart_type='line', style=style)
if not(silent_plot): chart.plot()
return chart
except: pass
def plot_strategy_group_pnl_trades(self, silent_plot = False):
style = self.create_style("(bp)", "Individual Trade PnL")
# zero when there isn't a trade exit
# strategy_pnl_trades = self._strategy_pnl_trades * 100 * 100
# strategy_pnl_trades = strategy_pnl_trades.dropna()
# note only works with single large basket trade
try:
strategy_pnl_trades = self._strategy_pnl_trades.fillna(0) * 100 * 100
chart = Chart(self.reduce_plot(strategy_pnl_trades), engine=self.DEFAULT_PLOT_ENGINE, chart_type='line', style=style)
if not(silent_plot): chart.plot()
return chart
except: pass
def venue_tca_aggregated_example():
"""Example of doing an aggregated TCA computation on a single ticker, and then later calculating the probability
distribution function of slippage split by venue (when weighted by executed notional)
"""
tca_engine = TCAEngineImpl(version=tca_version)
tca_request = TCARequest(start_date=start_date,
finish_date=finish_date,
ticker=ticker,
tca_type='aggregated',
trade_data_store=trade_data_store,
market_data_store=market_data_store,
metric_calcs=MetricSlippage())
dict_of_df = tca_engine.calculate_tca(tca_request)
summary = ResultsSummary()
summary_slippage_df = summary.field_distribution(
dict_of_df['trade_df'],
metric_name='slippage',
aggregate_by_field='venue',
pdf_only=True,
weighting_field='executed_notional')
# Plot PDF of slippage, split up by venue
Chart(engine='plotly').plot(summary_slippage_df,
style=Style(plotly_plot_mode='offline_html',
connect_line_gaps=True))
def __init__(self, computation_results, title='Cuemacro Computation'):
"""Initialize class, with the computation results we wish to convert into a report like format
Parameters
----------
computation_results : ComputationResults
The results of a large scale computation, which contains charts and DataFrames
title : str
Title of webpage to be rendered
"""
self._util_func = UtilFunc()
self._computation_results = computation_results
self._title = title
self._canvas_plotter = 'plain'
self._chart = Chart(engine='plotly')
def __init__(self, engine = ChartConstants().chartfactory_default_engine):
self.logger = LoggerManager().getLogger(__name__)
self.DUMP_PATH = 'output_data/' + datetime.date.today().strftime("%Y%m%d") + ' '
self.SCALE_FACTOR = 3
self.DEFAULT_PLOT_ENGINE = engine
self.chart = Chart(engine=self.DEFAULT_PLOT_ENGINE)
return
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 = None,
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
chart = Chart()
style = Style()
if title is None: title = statistic
style.title = title
style.display_legend = True
style.scale_factor = scale_factor
# style.color = ['red', 'blue', 'purple', 'gray', 'yellow', 'green', 'pink']
if output_path is not None:
style.file_output = output_path + ' (' + tag + ' ' + st + ').png'
chart.plot(stats_df, style=style)
return stats_df
def plot_strategy_trade_notional(self,
diff=True,
silent_plot=False,
reduce_plot=True):
"""
Plots the notional trades of the model
Returns the created Chart
Parameters
---------
diff
if you want to get the profit differences instead of raw values
silent_plot
if you want to only return the chart created
reduce_plot:
when plotting many points use WebGl version of plotly if specified
"""
style = self.models[self.ref_index]._create_style(
"", "Trades (Scaled by Notional)", reduce_plot=reduce_plot)
models = self.models
ref = self.ref_index
strategy_trade_notional = [
model._strategy_trade_notional for model in models
]
df = pd.concat(strategy_trade_notional, axis=1)
#if you want to get the profit differences instead of raw values
if diff:
df = df.subtract(strategy_trade_notional[ref], axis='index')
if self.labels is not None:
df.columns = self.labels
chart = Chart(df,
engine=self.DEFAULT_PLOT_ENGINE,
chart_type='bar',
style=style)
if not silent_plot:
chart.plot()
return chart
def plot_strategy_group_benchmark_pnl_ir(self, strip = None, silent_plot = False):
style = self.create_style("", "Group Benchmark PnL IR - cumulative")
keys = self._strategy_group_benchmark_ret_stats.keys()
ir = []
for key in keys:
ir.append(self._strategy_group_benchmark_ret_stats[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()
style.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - IR) ' + str(style.scale_factor) + '.png'
style.html_file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - IR) ' + str(style.scale_factor) + '.html'
style.display_brand_label = False
chart = Chart(ret_stats, engine=self.DEFAULT_PLOT_ENGINE, chart_type='bar', style=style)
if not (silent_plot): chart.plot()
return chart
def plot_sharpe(self, silent_plot=False, reduce_plot=True):
style = self.models[self.ref_index]._create_style(
"", "Sharpe Curve", reduce_plot=reduce_plot)
models = self.models
ref = self.ref_index
returns = [model._strategy_pnl.pct_change() for model in models]
stdev_of_returns = np.std(returns)
annualized_sharpe = returns / stdev_of_returns * np.sqrt(250)
df = pd.concat(annualized_sharpe, axis=1)
chart = Chart(df,
engine=self.DEFAULT_PLOT_ENGINE,
chart_type='bar',
style=style)
if not silent_plot:
chart.plot()
return chart
def __init__(self):
super(TradingModel, self).__init__()
##### FILL IN WITH YOUR OWN PARAMETERS FOR display, dumping, TSF etc.
self.market = Market(market_data_generator=MarketDataGenerator())
self.DUMP_PATH = ''
self.FINAL_STRATEGY = 'FX trend'
self.SCALE_FACTOR = 1
self.DEFAULT_PLOT_ENGINE = 'matplotlib'
self.chart = Chart(engine=self.DEFAULT_PLOT_ENGINE)
self.br = self.load_parameters()
return
def plot_strategy_trade_no(self, strip = None, silent_plot = False):
signal = self._strategy_signal
####### 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=trades.index, columns=['Trades'], data=trades)
if strip is not None: df_trades.index = [k.replace(strip, '') for k in df_trades.index]
style = self.create_style("", "")
try:
style.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy trade no).png'
style.html_file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy trade no).html'
chart = Chart(self.reduce_plot(df_trades), engine=self.DEFAULT_PLOT_ENGINE, chart_type='bar', style=style)
if not(silent_plot): chart.plot()
return chart
except:
pass
def calculate_button(self, *args):
n_clicks, ticker = args
if ticker == '':
return {}, "Here is an example of using chartpy with dash"
try:
df = pd.DataFrame(quandl.get(ticker))
df_vol = (df / df.shift(1)).rolling(
window=20).std() * math.sqrt(252) * 100.0
spot_fig = Chart(engine="plotly").plot(df,
style=Style(
title='Spot',
plotly_plot_mode='dash',
width=980,
height=480,
scale_factor=-1))
vol_fig = Chart(engine="plotly").plot(df_vol,
style=Style(
title='Realized Vol 1M',
plotly_plot_mode='dash',
width=980,
height=480,
scale_factor=-1))
msg = "Plotted " + ticker + " at " + datetime.datetime.utcnow(
).strftime("%b %d %Y %H:%M:%S")
return spot_fig, vol_fig, msg
except Exception as e:
print(str(e))
pass
return {}, "Failed to download"
def plot_pnl(self, diff=True, silent_plot=False, reduce_plot=True):
"""
Plots the profit and loss graph of the model.
Returns the created Chart
Parameters
---------
diff
if you want to get the profit differences instead of raw values
silent_plot
if you want to only return the chart created
reduce_plot
when plotting many points use WebGl version of plotly if specified
"""
style = self.models[self.ref_index]._create_style(
"", "Strategy PnL", reduce_plot=reduce_plot)
models = self.models
ref = self.ref_index
pnls = [model._strategy_pnl for model in models]
df = pd.concat(pnls, axis=1)
if diff:
df = df.subtract(pnls[ref], axis='index')
if self.labels is not None:
df.columns = self.labels
chart = Chart(df,
engine=self.DEFAULT_PLOT_ENGINE,
chart_type='line',
style=style)
if not silent_plot:
chart.plot()
return chart
def plot_pnl(self, diff=True, silent_plot=False, reduce_plot=True):
style = self.models[self.ref_index]._create_style(
"", "Strategy PnL", reduce_plot=reduce_plot)
models = self.models
ref = self.ref_index
pnls = [model._strategy_pnl for model in models]
df = pd.concat(pnls, axis=1)
if diff:
df = df.subtract(pnls[ref], axis='index')
if self.labels is not None:
df.columns = self.labels
chart = Chart(df,
engine=self.DEFAULT_PLOT_ENGINE,
chart_type='line',
style=style)
if not silent_plot:
chart.plot()
return chart
def plot_animated_vol_market():
market = Market(market_data_generator=MarketDataGenerator())
cross = ['GBPUSD']
start_date = '01 Jun 2016'
finish_date = '01 Aug 2016'
sampling = 'no'
md_request = MarketDataRequest(start_date=start_date,
finish_date=finish_date,
data_source='bloomberg',
cut='LDN',
category='fx-implied-vol',
tickers=cross,
cache_algo='internet_load_return')
df = market.fetch_market(md_request)
if sampling != 'no': df = df.resample(sampling).mean()
fxvf = FXVolFactory()
df_vs = []
# grab the vol surface for each date and create a dataframe for each date (could have used a panel)
for i in range(0, len(df.index)):
df_vs.append(fxvf.extract_vol_surface_for_date(df, cross[0], i))
style = Style(title="FX vol surface of " + cross[0],
source="chartpy",
color='Blues',
animate_figure=True,
animate_titles=df.index,
animate_frame_ms=500,
normalize_colormap=False)
# Chart object is initialised with the dataframe and our chart style
Chart(df=df_vs, chart_type='surface',
style=style).plot(engine='matplotlib')
__author__ = 'saeedamen'
# loading data
import datetime
from chartpy import Chart, Style
from findatapy.market import Market, MarketDataGenerator, MarketDataRequest
from findatapy.util.loggermanager import LoggerManager
logger = LoggerManager().getLogger(__name__)
chart = Chart(engine='matplotlib')
market = Market(market_data_generator=MarketDataGenerator())
# choose run_example = 0 for everything
# run_example = 1 - download BoE data from quandl
run_example = 0
###### fetch data from Quandl for BoE rate (using Bloomberg data)
if run_example == 1 or run_example == 0:
# Monthly average of UK resident monetary financial institutions' (excl. Central Bank) sterling
# Weighted average interest rate, other loans, new advances, on a fixed rate to private non-financial corporations (in percent)
# not seasonally adjusted
md_request = MarketDataRequest(
start_date="01 Jan 2000", # start date
data_source='quandl', # use Quandl as data source
tickers=['Weighted interest rate'],
fields=['close'], # which fields to download
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
style = Style()
style.scale_factor = 3
style.file_output = 'usdjpy-nfp.png'
style.title = 'USDJPY spot moves over recent NFP'
# plot in shades of blue (so earlier releases are lighter, later releases are darker)
style.color = 'Blues';
style.color_2 = []
style.y_axis_2_series = []
style.display_legend = False
# last release will be in red, average move in orange
style.color_2_series = [df_event.columns[-2], df_event.columns[-1]]
style.color_2 = ['red', 'orange'] # red, pink
style.linewidth_2 = 2
style.linewidth_2_series = style.color_2_series
chart = Chart(engine='matplotlib')
chart.plot(df_event * 100, style=style)
import pandas
from chartpy import Chart, Style
from finmarketpy.economics import Seasonality
from findatapy.market import Market, MarketDataGenerator, MarketDataRequest
from chartpy.style import Style
from findatapy.timeseries import Calculations
from findatapy.util.loggermanager import LoggerManager
seasonality = Seasonality()
calc = Calculations()
logger = LoggerManager().getLogger(__name__)
chart = Chart(engine='matplotlib')
market = Market(market_data_generator=MarketDataGenerator())
# choose run_example = 0 for everything
# run_example = 1 - seasonality of gold
# run_example = 2 - seasonality of FX vol
# run_example = 3 - seasonality of gasoline
# run_example = 4 - seasonality in NFP
# run_example = 5 - seasonal adjustment in NFP
run_example = 0
###### calculate seasonal moves in Gold (using Bloomberg data)
if run_example == 1 or run_example == 0:
md_request = MarketDataRequest(
class TradeAnalysis(object):
"""Applies some basic trade analysis for a trading strategy (as defined by TradingModel). Use PyFolio to create some
basic trading statistics. Also allows you test multiple parameters for a specific strategy (like TC).
"""
def __init__(self, engine = ChartConstants().chartfactory_default_engine):
self.logger = LoggerManager().getLogger(__name__)
self.DUMP_PATH = 'output_data/' + datetime.date.today().strftime("%Y%m%d") + ' '
self.SCALE_FACTOR = 3
self.DEFAULT_PLOT_ENGINE = engine
self.chart = Chart(engine=self.DEFAULT_PLOT_ENGINE)
return
def run_strategy_returns_stats(self, trading_model, index = None, engine = 'pyfolio'):
"""Plots useful statistics for the trading strategy (using PyFolio)
Parameters
----------
trading_model : TradingModel
defining trading strategy
index: DataFrame
define strategy by a time series
"""
if index is None:
pnl = trading_model.get_strategy_pnl()
else:
pnl = index
tz = Timezone()
calculations = Calculations()
if engine == 'pyfolio':
# PyFolio assumes UTC time based DataFrames (so force this localisation)
try:
pnl = tz.localise_index_as_UTC(pnl)
except: pass
# set the matplotlib style sheet & defaults
# at present this only works in Matplotlib engine
try:
matplotlib.rcdefaults()
plt.style.use(ChartConstants().chartfactory_style_sheet['chartpy-pyfolio'])
except: pass
# TODO for intraday strategies, make daily
# convert DataFrame (assumed to have only one column) to Series
pnl = calculations.calculate_returns(pnl)
pnl = pnl.dropna()
pnl = pnl[pnl.columns[0]]
fig = pf.create_returns_tear_sheet(pnl, return_fig=True)
try:
plt.savefig (trading_model.DUMP_PATH + "stats.png")
except: pass
plt.show()
elif engine == 'finmarketpy':
# assume we have TradingModel
# to do to take in a time series
from chartpy import Canvas, Chart
pnl = trading_model.plot_strategy_pnl(silent_plot=True) # plot the final strategy
individual = trading_model.plot_strategy_group_pnl_trades(silent_plot=True) # plot the individual trade P&Ls
pnl_comp = trading_model.plot_strategy_group_benchmark_pnl(silent_plot=True) # plot all the cumulative P&Ls of each component
ir_comp = trading_model.plot_strategy_group_benchmark_pnl_ir(silent_plot=True) # plot all the IR of each component
leverage = trading_model.plot_strategy_leverage(silent_plot=True) # plot the leverage of the portfolio
ind_lev = trading_model.plot_strategy_group_leverage(silent_plot=True) # plot all the individual leverages
canvas = Canvas([[pnl, individual],
[pnl_comp, ir_comp],
[leverage, ind_lev]]
)
canvas.generate_canvas(silent_display=False, canvas_plotter='plain')
def run_excel_trade_report(self, trading_model, excel_file = 'model.xlsx'):
"""
run_excel_trade_report - Creates an Excel spreadsheet with model returns and latest trades
Parameters
----------
trading_model : TradingModel
defining trading strategy (can be a list)
"""
trading_model_list = trading_model
if not(isinstance(trading_model_list, list)):
trading_model_list = [trading_model]
writer = pandas.ExcelWriter(excel_file, engine='xlsxwriter')
for tm in trading_model_list:
strategy_name = tm.FINAL_STRATEGY
returns = tm.get_strategy_group_benchmark_pnl()
returns.to_excel(writer, sheet_name=strategy_name + ' rets', engine='xlsxwriter')
# write raw position/trade sizes
self.save_positions_trades(tm, tm.get_strategy_signal(),tm.get_strategy_trade(),
'pos', 'trades', writer)
if hasattr(tm, '_strategy_signal_notional'):
# write position/trade sizes scaled by notional
self.save_positions_trades(tm,
tm.get_strategy_signal_notional(),
tm.get_strategy_trade_notional(), 'pos - Not', 'trades - Not', writer)
if hasattr(tm, '_strategy_signal_contracts'):
# write position/trade sizes in terms of contract sizes
self.save_positions_trades(tm,
tm.get_strategy_signal_contracts(),
tm.get_strategy_trade_contracts(), 'pos - Cont', 'trades - Cont', writer)
# TODO Add summary sheet comparing return statistics for all the different models in the list
writer.save()
writer.close()
def save_positions_trades(self, tm, signals, trades, signal_caption, trade_caption, writer):
signals.to_excel(writer, sheet_name=tm.FINAL_STRATEGY + ' hist ' + signal_caption, engine='xlsxwriter')
if hasattr(tm, 'STRIP'):
strip = tm.STRIP
recent_signals = tm.grab_signals(signals, date=[-1, -2, -5, -10, -20], strip=strip)
recent_trades = tm.grab_signals(trades, date=[-1, -2, -5, -10, -20], strip=strip)
recent_signals.to_excel(writer, sheet_name=tm.FINAL_STRATEGY + ' ' + signal_caption, engine='xlsxwriter')
recent_trades.to_excel(writer, sheet_name=tm.FINAL_STRATEGY + ' ' + trade_caption, engine='xlsxwriter')
def run_tc_shock(self, strategy, tc = None):
if tc is None: tc = [0, 0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2.0]
parameter_list = [{'spot_tc_bp' : x } for x in tc]
pretty_portfolio_names = [str(x) + 'bp' for x in tc] # names of the portfolio
parameter_type = 'TC analysis' # broad type of parameter name
return self.run_arbitrary_sensitivity(strategy,
parameter_list=parameter_list,
pretty_portfolio_names=pretty_portfolio_names,
parameter_type=parameter_type)
###### Parameters and signal generations (need to be customised for every model)
def run_arbitrary_sensitivity(self, trading_model, parameter_list = None, parameter_names = None,
pretty_portfolio_names = None, parameter_type = None):
asset_df, spot_df, spot_df2, basket_dict = trading_model.load_assets()
port_list = None
ret_stats_list = []
for i in range(0, len(parameter_list)):
br = trading_model.load_parameters()
current_parameter = parameter_list[i]
# for calculating P&L
for k in current_parameter.keys():
setattr(br, k, current_parameter[k])
trading_model.br = br # for calculating signals
signal_df = trading_model.construct_signal(spot_df, spot_df2, br.tech_params, br)
backtest = Backtest()
self.logger.info("Calculating... " + str(pretty_portfolio_names[i]))
backtest.calculate_trading_PnL(br, asset_df, signal_df)
ret_stats_list.append(backtest.get_portfolio_pnl_ret_stats())
stats = str(backtest.get_portfolio_pnl_desc()[0])
port = 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
trading_model.br = trading_model.load_parameters()
style = Style()
ir = [t.inforatio()[0] for t in ret_stats_list]
# if we have too many combinations remove legend and use scaled shaded colour
# if len(port_list) > 10:
# style.color = 'Blues'
# style.display_legend = False
# plot all the variations
style.resample = 'B'
style.file_output = self.DUMP_PATH + trading_model.FINAL_STRATEGY + ' ' + parameter_type + '.png'
style.html_file_output = self.DUMP_PATH + trading_model.FINAL_STRATEGY + ' ' + parameter_type + '.html'
style.scale_factor = self.SCALE_FACTOR
style.title = trading_model.FINAL_STRATEGY + ' ' + parameter_type
self.chart.plot(port_list, chart_type='line', style=style)
# plot all the IR in a bar chart form (can be easier to read!)
style = Style()
style.file_output = self.DUMP_PATH + trading_model.FINAL_STRATEGY + ' ' + parameter_type + ' IR.png'
style.html_file_output = self.DUMP_PATH + trading_model.FINAL_STRATEGY + ' ' + parameter_type + ' IR.html'
style.scale_factor = self.SCALE_FACTOR
style.title = trading_model.FINAL_STRATEGY + ' ' + parameter_type
summary = pandas.DataFrame(index = pretty_portfolio_names, data = ir, columns = ['IR'])
self.chart.plot(summary, chart_type='bar', style=style)
return port_list
###### Parameters and signal generations (need to be customised for every model)
###### Plot all the output seperately
def run_arbitrary_sensitivity_separately(self, trading_model, parameter_list = None,
pretty_portfolio_names = None, strip = None):
# asset_df, spot_df, spot_df2, basket_dict = strat.fill_assets()
final_strategy = trading_model.FINAL_STRATEGY
for i in range(0, len(parameter_list)):
br = trading_model.fill_backtest_request()
current_parameter = parameter_list[i]
# for calculating P&L
for k in current_parameter.keys():
setattr(br, k, current_parameter[k])
trading_model.FINAL_STRATEGY = final_strategy + " " + pretty_portfolio_names[i]
self.logger.info("Calculating... " + pretty_portfolio_names[i])
trading_model.br = br
trading_model.construct_strategy(br = br)
trading_model.plot_strategy_pnl()
trading_model.plot_strategy_leverage()
trading_model.plot_strategy_group_benchmark_pnl(strip = strip)
# reset the parameters of the strategy
trading_model.br = trading_model.fill_backtest_request()
trading_model.FINAL_STRATEGY = final_strategy
def run_day_of_month_analysis(self, trading_model):
from finmarketpy.economics.seasonality import Seasonality
calculations = Calculations()
seas = Seasonality()
trading_model.construct_strategy()
pnl = trading_model.get_strategy_pnl()
# get seasonality by day of the month
pnl = pnl.resample('B').mean()
rets = calculations.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 = calculations.calculate_returns(pnl)
month = seas.monthly_seasonality(rets)
self.logger.info("About to plot seasonality...")
style = Style()
# Plotting spot over day of month/month of year
style.color = 'Blues'
style.scale_factor = self.SCALE_FACTOR
style.file_output = self.DUMP_PATH + trading_model.FINAL_STRATEGY + ' seasonality day of month.png'
style.html_file_output = self.DUMP_PATH + trading_model.FINAL_STRATEGY + ' seasonality day of month.html'
style.title = trading_model.FINAL_STRATEGY + ' day of month seasonality'
style.display_legend = False
style.color_2_series = [bus_day.columns[-1]]
style.color_2 = ['red'] # red, pink
style.linewidth_2 = 4
style.linewidth_2_series = [bus_day.columns[-1]]
style.y_axis_2_series = [bus_day.columns[-1]]
self.chart.plot(bus_day, chart_type='line', style=style)
style = Style()
style.scale_factor = self.SCALE_FACTOR
style.file_output = self.DUMP_PATH + trading_model.FINAL_STRATEGY + ' seasonality month of year.png'
style.html_file_output = self.DUMP_PATH + trading_model.FINAL_STRATEGY + ' seasonality month of year.html'
style.title = trading_model.FINAL_STRATEGY + ' month of year seasonality'
self.chart.plot(month, chart_type='line', style=style)
return month
