def push_notebook(self):
""" Update date for a plot in the IPthon notebook in place.
This function can be be used to update data in plot data sources
in the IPython notebook, without having to use the Bokeh server.
Returns:
None
.. warning::
The current implementation leaks memory in the IPython notebook,
due to accumulating JS code. This function typically works well
with light UI interactions, but should not be used for continuously
updating data. See :bokeh-issue:`1732` for more details and to
track progress on potential fixes.
"""
from IPython.core import display
from bokeh.protocol import serialize_json
id = self.ref['id']
model = self.ref['type']
json = serialize_json(self.vm_serialize())
js = """
var ds = Bokeh.Collections('{model}').get('{id}');
var data = {json};
ds.set(data);
""".format(model=model, id=id, json=json)
display.display_javascript(js, raw=True)
def load_ipython_extension(ip):
ip.magics_manager.register(CsoundMagics)
ip.user_ns['runCsd'] = runCsd
ip.user_ns['runOrcSco'] = runOrcSco
ip.user_ns['ICsound'] = ICsound
js = "IPython.CodeCell.config_defaults.highlight_modes['magic_csound'] = {'reg':[/^%%csound/, /^%%csd/, /^%%orc/, /^%%sco/]};"
display_javascript(js, raw=True)
def reset(self):
out = None
if self.cell != "":
if self.runAsDecl:
utils.declareCppCode(self.cell)
self.runAsDecl = False
elif self.runAsAclic:
utils.invokeAclic(self.cell)
self.runAsAclic = False
elif self.runAsBash:
cellNoEndNewLine = self.cell[:-1]
out = utils._checkOutput(cellNoEndNewLine,"Error running shell command")
if out: sys.stdout.write(out)
self.runAsBash = False
else:
utils.processCppCode(self.cell)
self.cell = ""
if self.mustSwitchToPython:
ip = get_ipython()
unload_ipython_extension(ip)
self.mustSwitchToPython = False
cppcompleter.unload_ipython_extension(ip)
# Change highlight mode
display.display_javascript(utils.jsDefaultHighlight.format(mimeType = utils.ipyMIME), raw=True)
print "Notebook is in Python mode"
def load_ipython_extension(ipython):
ipython.register_magics(ODPSSql)
js = "IPython.CodeCell.config_defaults.highlight_modes['magic_sql'] = {'reg':[/^%%sql/]};"
display_javascript(js, raw=True)
# Do global import when load extension
ipython.user_ns['DataFrame'] = DataFrame
ipython.user_ns['Scalar'] = Scalar
ipython.user_ns['options'] = options
def display(self, speed=1000, from_start=False, reset_io=False, buffer_num=0):
"""
Display an animation, based on a starting state & the logged diff
Once this is called, the starting state & log mark are advanced
"""
self.log_buffer_data_diffs()
# Create a new html pane with unique id
chart_id = "%s-%s" % (buffer_num, self._chart_num)
html = """
<table>
<tr><th><i>IO Counts</i></th><th>R</th><th>W</th></tr>
<tr>
<td><i>To/from Buffer</i></td>
<td id="chart-{0}-bufferReads">0</td>
<td id="chart-{0}-bufferWrites">0</td>
</tr>
<tr>
<td><b>To/from Disk</b></td>
<td id="chart-{0}-diskReads">0</td>
<td id="chart-{0}-diskWrites">0</td>
</tr>
</table>
<br />
<div class="tooltip" id="chart-{0}-tooltip" style="position:absolute; z-index:100; color:white; background:black; opacity:0.7; padding:3px; border-radius:5px; display:none;">TOOLTIP!</div>
<div class="tooltip" id="chart-{0}-tooltip-2" style="position:absolute; z-index:100; color:white; background:black; opacity:0.7; padding:3px; border-radius:5px; display:none;">TOOLTIP!</div>
<div id="chart-{0}"></div>
""".format(
chart_id
)
# Dump log to json file
with open("pagesLog.json", "wb") as f:
json.dump(self._log, f)
# Create animation in js/d3
js_configs = {
"DURATION": speed,
"chartNum": chart_id,
"numBufferPages": self.buffer_size,
"pageSize": self.page_size,
"numDiskPages": 5,
"logStart": self._diff_log_start if not from_start else 0,
}
js = js_file_with_configs("compModel.js", js_configs)
js_libs = [
"http://rawgithub.com/mbostock/d3/master/d3.min.js",
"https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js",
"https://ajax.googleapis.com/ajax/libs/jqueryui/1.11.4/jquery-ui.min.js",
]
display_html(HTML(data=html))
display_javascript(Javascript(data=js, lib=js_libs))
self._chart_num += 1
# Advance current animation state in log
self.display_set_mark(reset_io=reset_io)
def load_ipython_extension(ip):
"""Load the extension in IPython."""
ip.register_magics(FortranMagics)
# enable fortran highlight
patch = ("IPython.config.cell_magic_highlight['magic_fortran'] = "
"{'reg':[/^%%fortran/]};")
js = display.Javascript(data=patch,
lib=["https://raw.github.com/marijnh/CodeMirror/master/mode/"
"fortran/fortran.js"])
display.display_javascript(js)
def load_ipython_extension(ip):
"""Load the extension in IPython."""
ip.register_magics(PigMagics)
# enable Pig highlight
js = display.Javascript(data=js_string)
display.display_javascript(js)
# some custom CSS to augment the syntax highlighting
css = display.HTML(css_string)
display.display_html(css)
def push_notebook(self):
from IPython.core import display
from bokeh.protocol import serialize_json
id = self.ref['id']
model = self.ref['type']
json = serialize_json(self.vm_serialize())
js = """
var ds = Bokeh.Collections('{model}').get('{id}');
var data = {json};
ds.set(data);
""".format(model=model, id=id, json=json)
display.display_javascript(js, raw=True)
def display(self, chart_num=0, configs_in={}):
"""Display the TXN viewer based on full current log"""
# dump input txns to jsonfor transfer to js
with open('txnLog.json', 'wb') as f:
json.dump(self._log, f)
# merge default configs
config = {
'chartNum': chart_num,
'numThreads': self.n_threads
}
config.update(configs_in)
js = ''.join('var %s = %s\n' % (k,v) for k,v in config.iteritems())
# JS
js += open('txnViewer.js', 'rb').read()
js_libs = [
'http://rawgithub.com/mbostock/d3/master/d3.min.js',
'https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js',
'https://ajax.googleapis.com/ajax/libs/jqueryui/1.11.4/jquery-ui.min.js'
]
# HTML
html_scripts = [
'<link rel="stylesheet" href="https://ajax.googleapis.com/ajax/libs/jqueryui/1.11.4/themes/smoothness/jquery-ui.css">'
]
html="""
<head>{0}</head>
<h3>TXN VIEWER</h3>
<table style="border: none; border-collapse: collapse;">
<tr style="border: none;">
<td style="border: none;">
<div id="top-spacer-{1}"></div>
<div id="chart-{1}"></div>
<div id="slider-{1}"></div>
</td>
<td style="vertical-align:top; border: none;">
<table id="vals-{1}"></table>
</td>
</tr>
<tr style="border: none;">
<td colspan="2" style="border: none;"><h4>The Log</h4></td>
</tr>
<tr><td colspan="2"><div id="log-{1}"></td></tr>
</table>
""".format(''.join(html_scripts), chart_num)
# Display in IPython notebook
display_html(HTML(data=html))
display_javascript(Javascript(data=js, lib=js_libs))
def __init__(self, *args, **kwargs):
super(NowSQL, self).__init__(*args, **kwargs)
javascript = """
var mode = 'magic_text/x-sql';
if (!Jupyter.CodeCell.options_default.highlight_modes[mode]) {
Jupyter.CodeCell.options_default.highlight_modes[mode] = {
'reg':[]
};
}
Jupyter.CodeCell.options_default.highlight_modes[mode].reg.push(
/^%%now_sql/
);
"""
display_javascript(javascript, raw=True)
def __init__(self, *args, **kwargs):
super(NowSQL, self).__init__(*args, **kwargs)
js = """
var mode = 'magic_text/x-sql';
if (!IPython.CodeCell.config_defaults.highlight_modes[mode]) {
IPython.CodeCell.config_defaults.highlight_modes[mode] = {
'reg':[]
};
}
IPython.CodeCell.config_defaults.highlight_modes[mode].reg.push(
/^%%now_sql/
);
""";
display_javascript(js, raw=True)
def render_tree(self):
"""
Renders d3 visualization of the d3 tree, for IPython notebook display
Depends on html/js files in vis/ directory, which is assumed to be in same dir...
:return:
"""
# TODO: Make better control over what format / what attributes displayed @ nodes!
html = open('lib/vis/tree-chart.html').read() % self.id
display_html(HTML(data=html))
# JS
JS_LIBS = ["https://d3js.org/d3.v3.min.js"]
js = open('lib/vis/tree-chart.js').read() % (json.dumps(self.json), self.id)
display_javascript(Javascript(data=js, lib=JS_LIBS))
def add_syntax_coloring():
"""Adds syntax coloring to cell magic for SELECT, FROM, etc."""
js_sql_syntax = '''
require(['notebook/js/codecell'], function(codecell) {
// https://github.com/jupyter/notebook/issues/2453
codecell.CodeCell.options_default.highlight_modes['magic_text/x-sql'] = {'reg':[/^%read_sql/, /.*=\s*%read_sql/,
/^%%read_sql/]};
Jupyter.notebook.events.one('kernel_ready.Kernel', function(){
console.log('BBBBB');
Jupyter.notebook.get_cells().map(function(cell){
if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;
});
});
'''
display_javascript(js_sql_syntax, raw=True)
def render_tree(self, highlight=[]):
"""
Renders d3 visualization of the d3 tree, for IPython notebook display
Depends on html/js files in vis/ directory, which is assumed to be in same dir...
"""
# HTML
WORD = '<span class="word-' + self.id + '-%s">%s</span>'
words = ' '.join(WORD % (i,w) for i,w in enumerate(corenlp_cleaner(self.words))) if self.words else ''
html = open('%s/vis/tree-chart.html' % APP_HOME).read() % (self.id, self.id, words)
display_html(HTML(data=html))
# JS
JS_LIBS = ["http://d3js.org/d3.v3.min.js"]
js = open('%s/vis/tree-chart.js' % APP_HOME).read() % (self.id, json.dumps(self.to_json()), str(highlight))
display_javascript(Javascript(data=js, lib=JS_LIBS))
def reset(self):
if self.cell != "":
if self.mustDeclare:
utils.declareCppCode(self.cell)
self.mustDeclare = False
else:
utils.processCppCode(self.cell)
self.cell = ""
if self.mustSwitchToPython:
ip = get_ipython()
unload_ipython_extension(ip)
self.mustSwitchToPython = False
cppcompleter.unload_ipython_extension(ip)
# Change highlight mode
display.display_javascript(utils.jsDefaultHighlight.format(mimeType = utils.ipyMIME), raw=True)
print "Notebook is in Python mode"
def _display_dataframe(self, data, update=None):
table_id = 'table_{}'.format(
update._df_display_id if update else self._df_display_id)
columns = [{
'title': ''
}] + [{
'title': str(column)
} for column in data.columns]
format_window_info_in_dataframe(data)
# Convert the dataframe into rows, each row looks like
# [column_1_val, column_2_val, ...].
rows = data.applymap(lambda x: str(x)).to_dict('split')['data']
# Convert each row into dict where keys are column index in the datatable
# to be rendered and values are data from the dataframe. Column index 0 is
# left out to hold the int index (not part of the data) from dataframe.
# Each row becomes: {1: column_1_val, 2: column_2_val, ...}.
rows = [{k + 1: v for k, v in enumerate(row)} for row in rows]
# Add the dataframe int index (used as default ordering column) to datatable
# column index 0 (will be rendered as the first column).
# Each row becomes:
# {1: column_1_val, 2: column_2_val, ..., 0: int_index_in_dataframe}.
for k, row in enumerate(rows):
row[0] = k
script = _DATAFRAME_SCRIPT_TEMPLATE.format(table_id=table_id,
columns=columns,
data_as_rows=rows)
script_in_jquery_with_datatable = ie._JQUERY_WITH_DATATABLE_TEMPLATE.format(
customized_script=script)
# Dynamically load data into the existing datatable if not empty.
if update and not update._is_datatable_empty:
display_javascript(Javascript(script_in_jquery_with_datatable))
else:
html = _DATAFRAME_PAGINATION_TEMPLATE.format(
table_id=table_id,
script_in_jquery_with_datatable=script_in_jquery_with_datatable
)
if update:
if not data.empty:
# Re-initialize a datatable to replace the existing empty datatable.
update_display(HTML(html),
display_id=update._df_display_id)
update._is_datatable_empty = False
else:
# Initialize a datatable for the first time rendering.
display(HTML(html), display_id=self._df_display_id)
if not data.empty:
self._is_datatable_empty = False
def __exit__(self, exc_type, exc_value, traceback):
try:
from IPython.core.display import Javascript
from IPython.core.display import display
from IPython.core.display import display_javascript
from apache_beam.runners.interactive import interactive_environment as ie
if ie.current_env().is_in_notebook:
script = self.spinner_removal_template.format(id=self._id)
display_javascript(
Javascript(
ie._JQUERY_WITH_DATATABLE_TEMPLATE.format(
customized_script=script)))
else:
display(self._exit_text)
except ImportError as e:
_LOGGER.error('Please use interactive Beam features in an IPython'
'or notebook environment: %s' % e)
def _display_overview(self, data, update=None):
if (not data.empty and self._include_window_info and
all(column in data.columns
for column in ('event_time', 'windows', 'pane_info'))):
data = data.drop(['event_time', 'windows', 'pane_info'], axis=1)
gfsg = GenericFeatureStatisticsGenerator()
proto = gfsg.ProtoFromDataFrames([{'name': 'data', 'table': data}])
protostr = base64.b64encode(proto.SerializeToString()).decode('utf-8')
if update:
script = _OVERVIEW_SCRIPT_TEMPLATE.format(
display_id=update._overview_display_id, protostr=protostr)
display_javascript(Javascript(script))
else:
html = _OVERVIEW_HTML_TEMPLATE.format(
display_id=self._overview_display_id, protostr=protostr)
display(HTML(html))
def render_tree(self, highlight=[]):
"""
Renders d3 visualization of the d3 tree, for IPython notebook display
Depends on html/js files in vis/ directory, which is assumed to be in same dir...
"""
# HTML
WORD = '<span class="word-' + self.id + '-%s">%s</span>'
words = ' '.join(WORD % (i, w) for i, w in enumerate(
corenlp_cleaner(self.words))) if self.words else ''
html = open('%s/vis/tree-chart.html' %
APP_HOME).read() % (self.id, self.id, words)
display_html(HTML(data=html))
# JS
JS_LIBS = ["https://d3js.org/d3.v3.min.js"]
js = open('%s/vis/tree-chart.js' % APP_HOME).read() % (
self.id, json.dumps(self.to_json()), str(highlight))
display_javascript(Javascript(data=js, lib=JS_LIBS))
def reset(self):
if self.cell != "":
if self.mustDeclare:
utils.declareCppCode(self.cell)
self.mustDeclare = False
else:
cell = self.cell
code = commentRemover(self.cell)
utils.processCppCode(code)
self.cell = ""
if self.mustSwitchToPython:
unload_ipython_extension(get_ipython())
self.mustSwitchToPython = False
cppcompleter.unload_ipython_extension(get_ipython())
# Change highlight mode
display.display_javascript(
utils.jsDefaultHighlight.format(mimeType=utils.ipyMIME),
raw=True)
print "Notebook is in Python mode"
def coffeescript_recipe(input_filename, input_dir="", output_dir=""):
input_path_full = os.path.join(input_dir, input_filename)
file_stem = input_filename.split('.coffee')[0]
output_file_name = os.path.join(output_dir, file_stem + '.js')
if not os.path.exists(output_file_name) or\
os.path.getmtime(input_path_full)>os.path.getmtime(output_file_name):
# Compile coffeescript to javascript + source map
subprocess.check_output(['coffee', '-c', '-m','-o', output_dir,
input_path_full],
stderr=subprocess.STDOUT)
output_mapping_file_name = os.path.join(output_dir, file_stem + '.js.map')
# Coffeescript can only output source maps as files and they are bound by their file names
# So for inlined javascript it is necessary to wrangle the two output files
js_code = file(output_file_name).read()
# Remove sourceMappingUrl directive which contains a useless file name
js_code = "\n".join([line for line in js_code.split("\n")
if not line.startswith('//# sourceMappingURL=')])
# Load coffeescript source code for inclusion into source map
coffee_code = file(os.path.join(input_dir, input_filename)).read()
# load source map as a dict structure to amend some particulars
mapping = json.loads(file(output_mapping_file_name).read())
# In Chrome Dev Tools newly inlined source maps don't replace old source maps for the same file name
unique_token = os.urandom(4).encode('hex') # Create a relatively unique token
# Change source map to work nicely when inlined
mapping['sourceRoot'] = ''
mapping['sourcesContent'] = [coffee_code]
mapping['sources'] = [input_filename + unique_token]
mapping['file'] = input_filename + unique_token
source_map = json.dumps(mapping)
js_code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,"+source_map.encode("base64").replace('\n', '')+'\n'
display.display_javascript(js_code, raw=True)
def setup_notebook():
# assign text/x-c++src MIME type to pybind11 cells
code = """
require(['notebook/js/codecell'], function(cc) {
cc.CodeCell.options_default.highlight_modes['magic_text/x-c++src'] =
{reg: [/^\s*%%pybind11/]};
});
"""
display_javascript(Javascript(data=code))
# assign non-black colour to C/C++ keywords
html = """
<style>
.cm-s-ipython span.cm-variable-3 {
color: #208ffb;
font-weight: bold;
}
</style>
"""
display_html(HTML(data=html))
def import_html_to_head(self, html_hrefs):
"""Imports given external HTMLs (supported through webcomponents) into
the head of the document.
On load of webcomponentsjs, import given HTMLs. If HTML import is already
supported, skip loading webcomponentsjs.
No matter how many times an HTML import occurs in the document, only the
first occurrence really embeds the external HTML. In a notebook environment,
the body of the document is always changing due to cell [re-]execution,
deletion and re-ordering. Thus, HTML imports shouldn't be put in the body
especially the output areas of notebook cells.
"""
try:
from IPython.core.display import Javascript
from IPython.core.display import display_javascript
display_javascript(
Javascript(_HTML_IMPORT_TEMPLATE.format(hrefs=html_hrefs)))
except ImportError:
pass # NOOP if dependencies are not available.
def load_jquery_with_datatable(self):
"""Loads common resources to enable jquery with datatable configured for
notebook frontends if necessary. If the resources have been loaded, NOOP.
A window.interactive_beam_jquery with datatable plugin configured can be
used in following notebook cells once this is invoked.
#. There should only be one jQuery imported.
#. Datatable needs to be imported after jQuery is loaded.
#. Imported jQuery is attached to window named as jquery[version].
#. The window attachment needs to happen at the end of import chain until
all jQuery plugins are set.
"""
try:
from IPython.core.display import Javascript
from IPython.core.display import display_javascript
display_javascript(
Javascript(
_JQUERY_WITH_DATATABLE_TEMPLATE.format(customized_script='')))
except ImportError:
pass # NOOP if dependencies are not available.
def _register_syntax_highlighting(): # pragma: no cover
from IPython.core import display
types = map(str, _SQL_TO_PYTHON_FRAMES.keys())
functions = list(RexCallPlugin.OPERATION_MAPPING.keys())
# Create a new mimetype
mime_type = {
"name": "sql",
"keywords": _create_set(KEYWORDS + functions),
"builtin": _create_set(types),
"atoms": _create_set(["false", "true", "null"]),
# "operatorChars": /^[*\/+\-%<>!=~&|^]/,
"dateSQL": _create_set(["time"]),
# More information
# https://opensource.apple.com/source/WebInspectorUI/WebInspectorUI-7600.8.3/UserInterface/External/CodeMirror/sql.js.auto.html
"support": _create_set(["ODBCdotTable", "doubleQuote", "zerolessFloat"]),
}
# Code original from fugue-sql, adjusted for dask-sql and using some more customizations
js = (
r"""
require(["codemirror/lib/codemirror"]);
// We define a new mime type for syntax highlighting
CodeMirror.defineMIME("text/x-dasksql", """
+ json.dumps(mime_type)
+ r"""
);
CodeMirror.modeInfo.push({
name: "Dask SQL",
mime: "text/x-dasksql",
mode: "sql"
});
"""
)
display.display_javascript(js + _JS_ENABLE_DASK_SQL, raw=True)
def run_js(js):
display_javascript(js, raw=True)
def load_ipython_extension(ipython):
ipython.register_magics(ODPSSql)
js = "IPython.CodeCell.config_defaults.highlight_modes['magic_sql'] = {'reg':[/^%%sql/]};"
display_javascript(js, raw=True)
def __init__(self, *args, **kwargs):
super(CypherMagic, self).__init__(*args, **kwargs)
display_javascript(js, raw=True)
def __init__(self, *args, **kwargs):
super(CypherMagic, self).__init__(*args, **kwargs)
display_javascript(js, raw=True)
def load_ipython_extension(ip):
js = "IPython.CodeCell.config_defaults.highlight_modes['magic_text/x-sql'] = {'reg':[/^%%sparksql/]};"
display_javascript(js, raw=True)
ip.register_magics(SparkSqlMagic)
pass
if len(fail_list) > 0:
print("The following macros could not be found: %s" % ', '.join(fail_list))
if len(macro_dict.keys()) > 0:
self.shell.push({'macro_dict' : macro_dict})
print("Several (%dx) macros have been added to the dictionary: macro_dict" % count_success),
with open(self._pid_file, 'w') as pid_text:
pid_text.write(','.join(map(str, self.pid_list)))
if not args.noprint:
if args.graph:
if not len(out) < 5:
print(out)
if re.search('could not find Graph window', out, flags=re.I) is None:
return Image(graph_out, retina=True)
else:
print('\nNo graph displayed, could not find one generated in this cell.')
else:
return print(out)
else:
return
# Register the magic function:
ip = get_ipython()
ip.register_magics(iPyStataMagic)
# Enable the stata syntax highlighting:
js = "IPython.CodeCell.config_defaults.highlight_modes['magic_stata'] = {'reg':[/^%%stata/]};"
display.display_javascript(js, raw=True)
def load_ipython_extension(ipython):
ipython.register_magics(ODPSSql)
js = "IPython.CodeCell.config_defaults.highlight_modes['magic_sql'] = {'reg':[/^%%sql/]};"
display_javascript(js, raw=True)
def javascript_recipe(input_filename, input_dir="", output_dir=""):
# Output dir is ignored because files are copied as-is
input_path_full = os.path.join(input_dir, input_filename)
js_code = file(input_path_full).read()
display.display_javascript(js_code, raw=True)
def import_pymb_magic():
# so many imports
from IPython.core.magic import (magics_class, Magics, cell_magic,
line_magic, MagicsManager)
from IPython.core.magic_arguments import (argument, kwds, defaults,
magic_arguments, parse_argstring)
from IPython.core.display import display_javascript
import PyMB
# turn on C++ highlighting for PyMB cells
display_javascript("IPython.config.cell_magic_highlight['magic_clike'] =" +
"{'reg':[/^%%PyMB/]};",
raw=True)
# define PyMB magic class
@magics_class
class PyMBMagics(Magics):
"""A PyMB magic for writing a model in .
"""
def __init__(self, shell):
"""
Parameters
----------
shell : IPython shell
"""
super(PyMBMagics, self).__init__(shell)
@magic_arguments()
@argument('name',
type=str,
help='The model name. A new model object will' +
' be created using this name.')
@argument('-NO_WRAP',
'--NO_WRAP_OBJ_FUN',
dest='WRAP',
action='store_false',
help='Turn off automatic wrapping of' +
' cell in objective function.')
@argument('-WRAP',
'--WRAP_OBJ_FUN',
dest='WRAP',
action='store_true',
help='Wrap the contents of the cell' +
' in an objective function.')
@defaults(WRAP=True)
@argument('-TMB',
'--TMB_DIR',
type=str,
default='/usr/local/lib/R/site-library/TMB/include',
help='''TMB_DIR : str, default ''' +
''' '/usr/local/lib/R/site-library/TMB/include'
location of TMB library''')
@argument('-R',
'--R_DIR',
type=str,
default='/usr/share/R/include',
help='''R_DIR : str, default '/usr/share/R/include'
location of R shared library
Note: R must be built with shared libraries
See http://stackoverflow.com/a/13224980/1028347''')
@argument('-LR',
'--R_LIB',
type=str,
default='/usr/share/R/include',
help='''R_LIB : str, default '/usr/lib/R/lib'
location of R library
Note: R must be built with shared libraries
See http://stackoverflow.com/a/13224980/1028347''')
@argument('-CC',
'--CCOMPILER',
type=str,
default='g++',
help='''CCOMPILER : str, default 'g++'
C++ compiler to use''')
@argument('-OUT',
'--OUTPUT_DIR',
type=str,
default='tmb_tmp',
help='''OUTPUT_DIR : str, default 'tmb_tmp'
output directory for .cpp and .o files''')
@argument('-I',
'--INCLUDE',
type=list,
default=['TMB.hpp'],
help='''INCLUDE : list, default ['TMB.hpp']
other libraries to include''')
@argument('-U',
'--USING',
type=list,
default=['namespace density'],
help='''USING: list, default ['namespace density']
namespaces, libraries, etc to' +
'' include, e.g. Eigen::SparseMatrix''')
@argument('-V',
'--VERBOSE',
dest='VERBOSE',
action='store_true',
help='''VERBOSE: boolean, default False
prints model code and compiler warnings''')
@argument('-Q',
'--QUIET',
dest='VERBOSE',
action='store_false',
help='''QUIET: boolean, default True
silences compiler output (opposite of verbose)''')
@defaults(VERBOSE=False)
@cell_magic
def PyMB(self, line, cell):
# parse arguments
args = parse_argstring(self.PyMB, line)
name = args.name
# opts = args.opts
# make a new model
model = PyMB.model(name=name)
self.shell.push({name: model})
print('Created model {}.'.format(name))
# create code string
code = ''
# add includes
for i in args.INCLUDE:
code += '#include <{}>\n'.format(i)
# add using
for u in args.USING:
code += 'using {};\n'.format(u)
# wrap cell in objective function by default
if args.WRAP:
code += 'template<class Type>\n'
code += 'Type objective_function<Type>::operator() () {\n'
# add cell contents (with tab indenting to make it look nicer)
code += '\n'.join([' ' + c for c in cell.split('\n')]) + '\n'
# close objective function
if args.WRAP:
code += '}\n'
# compile model
model.compile(codestr=code,
output_dir=args.OUTPUT_DIR,
cc=args.CCOMPILER,
R=args.R_DIR,
TMB=args.TMB_DIR,
LR=args.R_LIB,
verbose=args.VERBOSE)
# print if verbose
if args.VERBOSE:
print('Code:\n\n{}'.format(code))
ip = get_ipython()
ip.register_magics(PyMBMagics)
self.shell.push({args.output: output_ipys})
except:
print(
"Exception has occured. File could not be loaded. (Note, Pandas needs to be 0.17.x or higher.)"
)
if not args.noprint:
if args.graph:
if not len(out) < 5:
print(out)
if re.search('could not find Graph window', out,
flags=re.I) is None:
return IFrame('./temp_graph.pdf', width=700, height=400)
else:
print(
'\nNo graph displayed, could not find one generated in this cell.'
)
else:
return print(out)
else:
return
# Register the magic function:
ip = get_ipython()
ip.register_magics(iPyStataMagic)
# Enable the stata syntax highlighting:
js = "IPython.CodeCell.config_defaults.highlight_modes['magic_stata'] = {'reg':[/^%%stata/]};"
display.display_javascript(js, raw=True)
def _ipython_display_(self):
htmlcontent = '<div id="{arg1}" style="height: ' + str(self.height) + 'px; width:95%;"></div>'
display_html(htmlcontent.format(arg1=self.uuid),
raw=True
)
display_javascript(Javascript(data=(self.codestring % (self.uuid)), css=self.cssfile))
def load_ipython_extension(ip):
js = "IPython.CodeCell.config_defaults.highlight_modes['magic_text/x-sql'] = {'reg':[/^%%sparksql/]};"
display_javascript(js, raw=True)
ip.register_magics(SparkSqlMagic)
def load_ipython_extension(ip):
display_javascript("""console.log("Xcalar SQL magic loaded")""", raw=True)
"""Load the extension in IPython."""
utils.add_syntax_coloring()
ip.register_magics(SQL)