diff options
Diffstat (limited to 'python')
| -rw-r--r-- | python/globeop_reports.py | 109 | ||||
| -rw-r--r-- | python/notebooks/Allocation Reports.ipynb | 1693 |
2 files changed, 1789 insertions, 13 deletions
diff --git a/python/globeop_reports.py b/python/globeop_reports.py index 3e7eb3df..f5fa8dbb 100644 --- a/python/globeop_reports.py +++ b/python/globeop_reports.py @@ -1,42 +1,55 @@ from glob import iglob +from db import dbengine +from pandas.tseries.offsets import MonthEnd + import os import pandas as pd import datetime -from db import dbengine -from pandas.tseries.offsets import MonthEnd -import load_globeop_report as load_globeop +import numpy as np +import matplotlib.pyplot as plt +import pandas.tseries.offsets as off -def get_monthly_pnl(): +def get_monthly_pnl(group_by = ['identifier']): sql_string = "SELECT * FROM pnl_reports" df_pnl = pd.read_sql_query(sql_string, dbengine('dawndb'), parse_dates=['date'], index_col=['date']) df_pnl['identifier'] = df_pnl.invid.str.replace("_A$", "") pnl_cols = ['bookunrealmtm', 'bookrealmtm', 'bookrealincome', 'bookunrealincome', 'totalbookpl'] monthend_pnl = df_pnl.groupby(pd.TimeGrouper('M')).apply(lambda df: df.loc[df.index[-1]]) - return monthend_pnl.groupby(['date', 'identifier'])[['mtd' + col for col in pnl_cols]].sum() + return monthend_pnl.groupby(['date'] + group_by)[['mtd' + col for col in pnl_cols]].sum() + +def get_portfolio(report_date): + sql_string = "SELECT * FROM valuation_reports where periodenddate = %s" + df = pd.read_sql_query(sql_string, dbengine('dawndb'), parse_dates=['periodenddate'], + index_col=['periodenddate'], params=[report_date,]) + df['identifier'] = df.invid.str.replace("_A$", "") + return df def curr_port_PNL(date = datetime.date.today(), asset_class='Subprime'): - date = (date - pd.tseries.offsets.MonthEnd(1)).date() + date = (date - off.MonthEnd(1)).date() sql_string = "SELECT * FROM risk_positions(%s, %s) WHERE notional > 0" - df_positions = pd.read_sql_query(sql_string, dbengine('dawndb'),params = [date, asset_class]) + df_positions = pd.read_sql_query(sql_string, dbengine('dawndb'), params=[date, asset_class]) df_pnl = get_monthly_pnl()[:date] df_all = df_positions.merge(df_pnl.groupby('identifier').sum().reset_index(), on=['identifier']) return df_all def trade_performance(): sql_string = "SELECT * FROM bonds" - df_trades = pd.read_sql_query(sql_string, dbengine('dawndb'), parse_dates= ['lastupdate', 'trade_date','settle_date']) + df_trades = pd.read_sql_query(sql_string, dbengine('dawndb'), parse_dates=['lastupdate', 'trade_date', 'settle_date']) df_trades = df_trades[df_trades.asset_class == 'Subprime'] df_pnl = get_monthly_pnl() df_sell = df_trades[df_trades.buysell == False].groupby('identifier').last().reset_index() df_sell.identifier = df_sell.identifier.str[:9] - df_sell['trade_pnl_date'] = df_sell.trade_date + MonthEnd(0) + df_sell['trade_pnl_date'] = df_sell.trade_date + off.MonthEnd(0) df_buy = df_trades[df_trades.buysell == True].groupby('identifier').last().reset_index() df_all = df_sell.merge(df_pnl.groupby('identifier').sum().reset_index(), on=['identifier']) - df_all = df_all.merge(df_pnl.reset_index()[['date', 'identifier', 'mtdtotalbookpl']], left_on=['trade_pnl_date','identifier'], right_on=['date','identifier'], suffixes=('','_at_trade_month')) - df_all = df_all.drop(['date','trade_pnl_date'], axis = 1) + df_all = df_all.merge(df_pnl.reset_index()[['date', 'identifier', 'mtdtotalbookpl']], + left_on=['trade_pnl_date', 'identifier'], + right_on=['date', 'identifier'], + suffixes=('', '_at_trade_month')) + df_all = df_all.drop(['date', 'trade_pnl_date'], axis=1) #now build up the table g = df_buy.groupby('identifier').sum() @@ -65,7 +78,77 @@ def get_net_navs(): nav = nav.resample('M').last() df = pd.read_csv('/home/serenitas/edwin/Python/subscription_fee_data.csv', parse_dates=['date'], index_col =['date']) df.index = df.index.to_period('M').to_timestamp('M') - return df.join(nav) + df = df.join(nav) + df['begbooknav'] = (df.endbooknav + df.net_flow).shift(1) + df.at[('2013-01-31', 'begbooknav')] = 12500000 + return df + +def alloc(report_date, alloc = 'pnl'): + + """ Takes strategy grouping """ + "Alloc: pnl or capital" + + if alloc == 'pnl': + nav = get_net_navs() + df = get_monthly_pnl(['strat', 'custacctname']) + df = df.join(nav.begbooknav) + df['strat_return'] = df.mtdtotalbookpl / df.begbooknav + df = df.loc[report_date.date()] + elif alloc == 'capital': + df = get_portfolio(report_date) + df.set_index(['strat','custacctname'], inplace=True) + + #get strategy lookup table: group-by a merged DF to spot unmapped strategies + strats = pd.read_csv('/home/serenitas/edwin/Python/strat_map.csv', index_col=['strat','custacctname']) + #Check for empty sets: df.set_index(['strat','custacctname']).groupby(['strat','custacctname']) + df = df.merge(strats, left_index=True, right_index=True) + df = df.fillna(-1) + return df.set_index(alloc).groupby(alloc).sum() + +def pnl_alloc_plot(df): + + """ Takes the alloc('pnl') dataframe """ + y = df.strat_return + x = df.index + x_loc = np.arange(len(df.index)) + + width = .35 #width of the bar + fig, ax = plt.subplots(figsize = (6,6)) + ax.bar(x_loc, y, width) + + ax.set_xlabel('Strategy') + ax.set_xticks(x_loc + width /2) + ax.set_xticklabels(x, rotation='45') + + #set y-axis as percentage + ax.set_ylabel('Return (%)') + y_ticks = ax.get_yticks() + ax.set_yticklabels(['{:.2f}%'.format(y*100) for y in y_ticks]) + plt.tight_layout() + +def cap_alloc_plot(df): + + """ Takes the alloc('capital') dataframe""" + # create piechart and add a circle at the center + + df['alloc'] = df.endbooknav/df.endbooknav.sum() + fig, ax = plt.subplots(figsize=(8,4)) + ax.pie(df.alloc, labels=df.index, autopct='%1.1f%%', + pctdistance=1.25, labeldistance=1.5) + ax.add_artist(plt.Circle((0,0), 0.7, color='white')) + ax.axis('equal') + plt.tight_layout() + +def avg_turnover(): + #Total Bond Sales Proceeds/Average starting 12 months NAV + avg_nav = get_net_navs().begbooknav[-12:].mean() + last_monthend = datetime.date.today() - off.MonthEnd(1) + sql_string = "SELECT * FROM bonds where buysell = 'False'" + df = pd.read_sql_query(sql_string, dbengine('dawndb'), + parse_dates=['lastupdate', 'trade_date', 'settle_date']) + df = df[(df.trade_date > last_monthend - off.MonthEnd(12)) + & (df.trade_date <= last_monthend)] + return (df.principal_payment + df.accrued_payment).sum()/avg_nav def calc_trade_performance_stats(): df = trade_performance().set_index('trade_date') @@ -85,7 +168,7 @@ def calc_trade_performance_stats(): import pdb; pdb.set_trace() y = y.date().year results.loc[y] = df2[df2.days_held.notnull()].mean()[['curr_face','initialinvestment', 'days_held']] - results.loc[] = len(df2[df2.winners == x].index)/len(df) + #results.loc[] = len(df2[df2.winners == x].index)/len(df) df[df.days_held.notnull()]['days_held'].groupby(pd.TimeGrouper(freq='A')).mean() diff --git a/python/notebooks/Allocation Reports.ipynb b/python/notebooks/Allocation Reports.ipynb new file mode 100644 index 00000000..bddcef63 --- /dev/null +++ b/python/notebooks/Allocation Reports.ipynb @@ -0,0 +1,1693 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import datetime\n", + "import pandas.tseries.offsets as off\n", + "import globeop_reports as go" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Timestamp('2017-10-31 00:00:00')" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#PNL Allocation\n", + "#report_date = datetime.date(2017,10,31)\n", + "report_date = datetime.date.today()\n", + "report_date = report_date - off.MonthEnd(1)\n", + "report_date" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " this.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\" width=\"600\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pnl_alloc = go.alloc(report_date, 'pnl')\n", + "go.pnl_alloc_plot(pnl_alloc)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " this.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overriden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\" width=\"800\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Capital Allocation\n", + "cap_alloc = go.alloc(report_date, 'capital')\n", + "go.cap_alloc_plot(cap_alloc)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.5155553893824326" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Average Portfolio Sales Turnover - as of last monthend from today\n", + "go.avg_turnover()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} |