def install_nbextension(ip):
"""install the gist javascript extension, and load it in custom.js"""
gist_js = os.path.join(ip.ipython_dir, 'nbextensions', 'gistcomm.js')
url = "http://rawgithub.com/minrk/ipython_extensions/master/nbextensions/gistcomm.js"
here = os.path.dirname(__file__)
if not os.path.exists(gist_js):
local_gist_js = os.path.join(here, 'gistcomm.js')
if os.path.exists(local_gist_js):
print("installing gistcomm.js from %s" % local_gist_js)
gist_f = open(local_gist_js)
else:
print("installing gistcomm.js from %s" % url)
gist_f = urllib2.urlopen(url)
with open(gist_js, 'w') as f:
f.write(gist_f.read())
gist_f.close()
custom_js = os.path.join(ip.profile_dir.location, 'static', 'custom',
'custom.js')
already_required = False
if os.path.exists(custom_js):
with open(custom_js, 'r') as f:
js = f.read()
already_required = "nbextensions/gist" in js
if not already_required:
print("loading gist button into custom.js")
with open(custom_js, 'a') as f:
f.write(load_js)
display_javascript(load_js, raw=True)
def _ipython_display_(self):
js = """
require(["https://rawgit.com/caldwell/renderjson/master/renderjson.js"], function() {
renderjson.set_show_to_level(1)
renderjson.set_sort_objects(true)
renderjson.set_icons('▶', '▼')
document.getElementById('%s').appendChild(renderjson(%s))
});
""" % (self.uuid, self.json_str)
css = """
.renderjson a { text-decoration: none; }
.renderjson .disclosure { color: grey; text-decoration: none; }
.renderjson .syntax { color: grey; }
.renderjson .string { color: darkred; }
.renderjson .number { color: darkcyan; }
.renderjson .boolean { color: blueviolet; }
.renderjson .key { color: darkblue; }
.renderjson .keyword { color: blue; }
.renderjson .object.syntax { color: lightseagreen; }
.renderjson .array.syntax { color: orange; }
"""
display_html(
'<style>{}</style><div id="{}" style="height: 100%; width:100%;"></div>'
.format(css, self.uuid),
raw=True)
display_javascript(js, raw=True)
def _ipython_display_(self):
from IPython.display import display_javascript, display_html
from IPython.display import Javascript
jscode = self.js()
display_javascript(Javascript(jscode, lib=[D3, NVD3], css=[NVD3_CSS]))
display_html(self.html(), raw=True)
def _ipython_display_(self):
display_html("""<style>
.renderjson {background:%s;padding:10px;color:%s}
.renderjson a { color:lightblue; text-decoration: none; }
.renderjson .disclosure { color: crimson; font-size: 80%%; }
.xrenderjson .syntax { color: blue; }
.renderjson .string { color: #90a959; }
.renderjson .number { color: plum; }
.renderjson .boolean { color: #d28445; }
.renderjson .key { color: #90a959; }
.renderjson .keyword { color: #d28445; }
.xrenderjson .object.syntax { color: #ddd; }
.renderjson .array.syntax { color: #fff; }
</style>
<div id="%s" style="width:100%%;"></div>""" %
(self.bg_color, self.text_color, self.uuid),
raw=True)
display_javascript("""
require(["https://rawgit.com/caldwell/renderjson/master/renderjson.js"], function(r) {
var node = document.getElementById('%s');
node.innerHTML = ''; // vola se 2x neznamo proc
node.appendChild(renderjson.set_icons('\u25BA', '\u25BC').set_show_to_level(%s)(%s));
return true;
});
""" % (self.uuid, self.show_to_level, self.json_str),
raw=True)
def init_plotly_online_mode():
from IPython.display import display_javascript
from plotly import offline
offline.offline.__PLOTLY_OFFLINE_INITIALIZED = True
jscode = """
require.config({
paths: {
d3: 'http://cdnjs.cloudflare.com/ajax/libs/d3/3.5.16/d3.min',
plotly: 'http://cdn.plot.ly/plotly-1.10.0.min',
jquery: 'https://code.jquery.com/jquery-migrate-1.4.1.min'
},
shim: {
plotly: {
deps: ['d3', 'jquery'],
exports: 'plotly'
}
}
});
require(['d3', 'plotly'], function(d3, plotly) {
window.Plotly = plotly;
});
"""
display_javascript(jscode, raw=True)
def _ipython_display_(self):
display_html('<div id="{}" style="height: 600px; width:100%;"></div>'.format(self.uuid), raw=True)
display_javascript("""
require(["https://rawgit.com/caldwell/renderjson/master/renderjson.js"], function() {
document.getElementById('%s').appendChild(renderjson(%s))
});
""" % (self.uuid, self.json_str), raw=True)
def _ipython_display_(self):
try:
column_types_json = json.dumps(self.column_types)
data_frame_json = self.df_copy.to_json(
orient='records',
date_format='iso',
double_precision=self.precision,
)
options_json = json.dumps(self.grid_options)
if self.remote_js:
cdn_base_url = \
"https://cdn.rawgit.com/quantopian/qgrid/72d356cb123fab413dba73ec46616e4916fbd827/qgrid/qgridjs/"
else:
cdn_base_url = "/nbextensions/qgridjs"
raw_html = SLICK_GRID_CSS.format(
div_id=self.div_id,
cdn_base_url=cdn_base_url,
)
raw_js = SLICK_GRID_JS.format(
cdn_base_url=cdn_base_url,
div_id=self.div_id,
data_frame_json=data_frame_json,
column_types_json=column_types_json,
options_json=options_json,
)
display_html(raw_html, raw=True)
display_javascript(raw_js, raw=True)
except Exception as err:
display_html('ERROR: {}'.format(str(err)), raw=True)
def load_ipython_extension(ipython):
# Change input cell syntax highlighting to SQL
js = "IPython.CodeCell.options_default.highlight_modes['magic_sql'] = {'reg':[/^%%sqlflow/]};"
display_javascript(js, raw=True)
magics = SqlFlowMagic(ipython)
ipython.register_magics(magics)
def ____ipython_display_(self):
#base64 = file(os.path.join(base_path, "data.png")).read().encode("base64").replace("\n", "")
#base64_colormap = file(os.path.join(base_path, "colormap.png")).read().encode("base64").replace("\n", "")
#print base64[:10]
#code = "base64 = '" + base64 + "'; base64_colormap = '" + base64_colormap + "';"
display_javascript(open(os.path.join(base_path, "all.js")).read(),
raw=True)
display_javascript(file(
os.path.join(base_path, "vaex_volumerendering.js")).read(),
raw=True)
display_html(file(os.path.join(base_path, "snippet.js")).read(),
raw=True)
html1 = file(os.path.join(base_path, "snippet.html")).read()
display_html(html1, raw=True)
#print "ok"
display_html("""<div>BLAAT</div> """, raw=True)
if 0:
js1 = file(os.path.join(base_path, "snippet.js")).read()
js2 = file(os.path.join(base_path,
"vaex_volumerendering.js")).read()
js_lib = file(os.path.join(base_path, "all.js")).read()
html1 = file(os.path.join(base_path, "snippet.html")).read()
HTML("<script>" + js_lib + "\n" + code + "</script>" + "<script>" +
js2 + "</script>" + html1 + js1)
def install_nbextension(ip):
"""install the gist javascript extension, and load it in custom.js"""
gist_js = os.path.join(ip.ipython_dir, 'nbextensions', 'gistcomm.js')
url = "http://rawgithub.com/minrk/ipython_extensions/master/nbextensions/gistcomm.js"
here = os.path.dirname(__file__)
if not os.path.exists(gist_js):
local_gist_js = os.path.join(here, 'gistcomm.js')
if os.path.exists(local_gist_js):
print ("installing gistcomm.js from %s" % local_gist_js)
gist_f = open(local_gist_js)
else:
print ("installing gistcomm.js from %s" % url)
gist_f = urllib2.urlopen(url)
with open(gist_js, 'w') as f:
f.write(gist_f.read())
gist_f.close()
custom_js = os.path.join(ip.profile_dir.location, 'static', 'custom', 'custom.js')
already_required = False
if os.path.exists(custom_js):
with open(custom_js, 'r') as f:
js = f.read()
already_required = "nbextensions/gist" in js
if not already_required:
print("loading gist button into custom.js")
with open(custom_js, 'a') as f:
f.write(load_js)
display_javascript(load_js, raw=True);
def wavejson_to_wavedrom(wavejson, width=None):
'''
Create WaveDrom display from WaveJSON data.
This code is from https://github.com/witchard/ipython-wavedrom.
'''
# Set the width of the waveform display.
style = ''
if width != None:
style = ' style="width: {w}px"'.format(w=str(int(width)))
# Generate the HTML from the JSON.
htmldata = '<div{style}><script type="WaveDrom">{json}</script></div>'.format(
style=style, json=json.dumps(wavejson))
DISP.display_html(DISP.HTML(htmldata))
# Trigger the WaveDrom Javascript that creates the graphical display.
DISP.display_javascript(
DISP.Javascript(
data='WaveDrom.ProcessAll();',
lib=[
'http://wavedrom.com/wavedrom.min.js',
'http://wavedrom.com/skins/default.js'
]))
# The following allows the display of WaveDROM in the HTML files generated by nbconvert.
# It's disabled because it makes Github's nbconvert freak out.
setup = '''
def set_extra_text(self, text):
super(ProgressBarIPyNb, self).set_extra_text(text)
if self.quiet:
return
display_javascript('$("#%s > .text > .extra").text("|||| %s")' %
(self.html_id, text),
raw=True)
def _ipython_display_(self):
try:
column_types_json = json.dumps(self.column_types)
data_frame_json = self.df_copy.to_json(
orient='records',
date_format='iso',
double_precision=self.precision,
)
if self.remote_js:
cdn_base_url = \
"https://cdn.rawgit.com/quantopian/qgrid/ddf33c0efb813cd574f3838f6cf1fd584b733621/qgrid/qgridjs/"
else:
cdn_base_url = "/nbextensions/qgridjs"
raw_html = SLICK_GRID_CSS.format(
div_id=self.div_id,
cdn_base_url=cdn_base_url,
)
raw_js = SLICK_GRID_JS.format(
cdn_base_url=cdn_base_url,
div_id=self.div_id,
data_frame_json=data_frame_json,
column_types_json=column_types_json,
)
display_html(raw_html, raw=True)
display_javascript(raw_js, raw=True)
except Exception as err:
display_html('ERROR: {}'.format(str(err)), raw=True)
def init_plotly_offline_mode():
from IPython.display import display_javascript
import shutil
from plotly import offline
from os import path
offline.offline.__PLOTLY_OFFLINE_INITIALIZED = True
shutil.copy(path.join(offline.__path__[0], "plotly.min.js"), ".")
jscode = """
require.config({
paths: {
plotly: "/files/" + Jupyter.notebook.notebook_path + "/../" + "plotly.min"
},
shim: {
plotly: {
deps: [],
exports: 'plotly'
}
}
});
require(['plotly'], function(plotly) {
window.Plotly = plotly;
console.log("Plotly loaded");
});
"""
display_javascript(jscode, raw=True)
def set_metadata_answer(question, field):
q = str(question)
answer = field.value
display_javascript(
Javascript(
"if('%s' in saveTimers) { clearTimeout(saveTimers['%s']); } saveTimers['%s'] = setTimeout(function() { if(!('uva_answers' in IPython.notebook.metadata)) { IPython.notebook.metadata['uva_answers'] = {} } IPython.notebook.metadata['uva_answers']['%s'] = '%s'; IPython.notebook.save_checkpoint(); }, 500)"
% (q, q, q, q, str(answer))))
def make_markdown_cell(s):
display_javascript("""var t_cell = IPython.notebook.get_selected_cell()
t_cell.set_text('<!--\\n' + t_cell.get_text() + '\\n--> \\n{}');
var t_index = IPython.notebook.get_cells().indexOf(t_cell);
IPython.notebook.to_markdown(t_index);
IPython.notebook.get_cell(t_index).render();""".format(
s.replace('\n', '\\n')),
raw=True)
def patch(force=False):
# return
global patched
if not patched or force:
display_javascript(open(os.path.join(base_path,
"bqplot_ext.js")).read(),
raw=True)
patched = True
def run_js(jscmd, force):
if (force):
jsf = Javascript(jscmd)
else:
jsf = Javascript("// Graffiti javascript\n" +
"if (window.Graffiti !== undefined) {\n" + jscmd +
"\n}\n")
display_javascript(jsf)
def _ipython_display_(self):
if display_html is not None:
display_html('<div id="{}" style="height: 600px; width:100%;"></div>'.format(self.__uuid), raw=True)
display_javascript("""
require(["https://rawgit.com/caldwell/renderjson/master/renderjson.js"], function() {
document.getElementById('%s').appendChild(renderjson(%s))
});
""" % (self.__uuid, self.json), raw=True)
def _ipython_display_(self):
display_html('<div id="{}" style="height: 150px; width:100%;"></div>'.format(self.uuid),
raw=True
)
display_javascript("""
require(["http://localhost:8080/files/renderjson.js"], function() {
document.getElementById('%s').appendChild(renderjson(%s))
});
""" % (self.uuid, self.json_str), raw=True)
def stopSparkStatus():
js = """
for (var i in window.myTimers) {
clearInterval(window.myTimers[i])
}
window.myTimers = []
$("#sparkStatusFooter").remove()
"""
display_javascript(Javascript(js))
def make_cell(s):
display_javascript("""
var t_cell = IPython.notebook.insert_cell_below()
t_cell.set_text( '{}');
var t_index = IPython.notebook.get_cells().indexOf(t_cell);
IPython.notebook.get_cell(t_index).render();
""".format(s.replace('\n', '\\n')),
raw=True)
def set(self, **kwargs):
settings = json.dumps(kwargs)
js_code = """var o = $('#%s').data('vr');
var new_settings = JSON.parse('%s');
console.log(new_settings);
console.log($.extend(o.settings, new_settings));
o.update_transfer_function_array()
o.drawScene();
""" % (self.id, settings)
display_javascript(js_code, raw=True)
def _ipython_display_(self):
display_html(html_content.replace("{{{#uuid#}}}", self.uuid).replace("{{{#domheight#}}}", self.domheight),
raw=True
)
display_javascript("var title="+"'" + self.title + "';\n"+\
"var data="+self.json_str+";\n"+\
"var uuid='"+self.uuid+"';\n"+\
javascript_content , raw=True)
def set(self, **kwargs):
settings = json.dumps(kwargs)
js_code = """var o = $('#%s').data('vr');
var new_settings = JSON.parse('%s');
console.log(new_settings);
console.log($.extend(o.settings, new_settings));
o.update_transfer_function_array()
o.drawScene();
""" % (self.id, settings)
display_javascript(js_code, raw=True)
def _ipython_display_(self):
json_already = json.dumps(self.already_run)
json_to_run = json.dumps(self.to_run)
display_html(
'<div id="{}" style="height: 300px; width:80%;"'
'data-already-run=\'{}\' '
'data-to-run=\'{}\'></div>'.format(self.uuid, json_already,
json_to_run),
raw=True)
display_javascript('window.turtle("{}");'.format(self.uuid),
raw=True)
def _ipython_display_(self):
"""
overloads method
`_ipython_display_ <http://ipython.readthedocs.io/en/stable/config/integrating.html?highlight=Integrating%20>`_.
"""
ht, js = self.generate_html()
if js is None:
display_html(ht, raw=True)
else:
display_html(ht, raw=True)
display_javascript(js, raw=True)
def _ipython_display_(self):
display_html(
'<head><link rel="stylesheet" type="text/css" href="json_formatter.css"></head><body><div id="{}" style="background-color: black;"></div></body>'
.format(self.uuid),
raw=True)
display_javascript("""
require(["https://rawgit.com/caldwell/renderjson/master/renderjson.js"], function() {
document.getElementById('%s').appendChild(renderjson(%s))
});
""" % (self.uuid, self.json_str),
raw=True)
def load_ipython_extension(ipython):
"""Called by IPython when this module is loaded as an IPython extension."""
from .magics import _cell_magic
from IPython.display import display_javascript
ipython.register_magic_function(_cell_magic,
magic_kind="cell",
magic_name="superquery")
# Enable syntax highlighting
js = "IPython.CodeCell.options_default.highlight_modes['magic_sql'] = {'reg':[/^%%superquery/]};"
display_javascript(js, raw=True)
def prompt_user(self):
self.description_store.before_prompt()
prompt_description_js = dedent("""\
// Guard against re-execution.
if (IPython.notebook.kernel) {
console.log("beginning of js");
var handle_output = function(out){
console.log(out.msg_type);
console.log(out);
var res = null;
if (out.msg_type == "stream"){
res = out.content.text;
}
// if output is a python object
else if(out.msg_type === "execute_result"){
res = out.content.data["text/plain"];
}
// if output is a python error
else if(out.msg_type == "error"){
res = out.content.ename + ": " + out.content.evalue;
}
// if output is something we haven't thought of
else{
res = "[out type not implemented]";
}
console.log(res);
};
var callback = {
iopub: {
output : handle_output,
}
};
var options = {
silent : false,
};
var description = prompt("Set description", "default");
var command = "a.description_store.set_description('" + description + "')";
console.log("executing " + command);
var kernel = IPython.notebook.kernel
kernel.execute(command, callback, options);
console.log("end of js");
}
""")
jso = Javascript(prompt_description_js)
display_javascript(jso)
description = self.description_store.get_description()
print("Description: {}".format(description))
return description
def load_ipython_extension(ipython):
out_handler = logging.StreamHandler(sys.stdout)
out_handler.setLevel(logging.INFO)
_LOGGER.addHandler(out_handler)
_LOGGER.setLevel(logging.INFO)
# Change input cell syntax highlighting to SQL
js = "IPython.CodeCell.options_default.highlight_modes['magic_sql'] = {'reg':[/^%%sqlflow/]};"
display_javascript(js, raw=True)
magics = SqlFlowMagic(ipython)
ipython.register_magics(magics)
def _ipython_display_(self):
display_javascript(open(
os.path.join(base_path, "glMatrix-0.9.5.min.js")).read(),
raw=True)
display_javascript(open(os.path.join(base_path,
"volumerenderer.js")).read(),
raw=True)
#cube64 = b64encode(file(os.path.join(base_path, "cube.png")).read())
colormap64 = b64encode(
open(os.path.join(base_path, "colormap.png"),
"rb").read()).decode("ascii")
src = """
window.colormap_src = 'data:image/png;base64,%s';
""" % (colormap64, )
#print(src)
display_javascript(src, raw=True)
js_code = "window.shader_cache = [];\n"
for name in ["cube", "texture", "volr"]:
for type in ["fragment", "vertex"]:
text = open(
os.path.join(base_path, "shaders",
name + "-" + type + ".shader")).read()
text = text.replace("\n", "\\n").replace("'", "\\'")
js_code += "window.shader_cache['{name}_{type}'] = '{text}';\n".format(
**locals())
display_javascript(js_code, raw=True)
def InsertTemplate(self):
from IPython.display import display_javascript
config = configparser.ConfigParser()
config.read('config.ini')
wps_deploy_path = config['PATH']['wpsdeploypath']
with open(wps_deploy_path + 'template.py', 'r') as content_file:
s = content_file.read()
text = s.replace('\n', '\\n').replace("\"", "\\\"").replace("'", "\\'")
text2 = """var t_cell = IPython.notebook.get_selected_cell()
t_cell.set_text('{}');
var t_index = IPython.notebook.get_cells().indexOf(t_cell);
IPython.notebook.to_code(t_index);
IPython.notebook.get_cell(t_index).render();""".format(text)
display_javascript(text2, raw=True)
def _ipython_display_(self):
json_str, uuid_str = json.dumps(self), str(uuid.uuid4())
display_html(
"<div id='{}' style='width:100%;'></div>".format(uuid_str),
raw=True)
display_javascript("""
require(["json.human"], function(JsonHuman) {
"use strict";
var data = JSON.parse('%s');
var node = JsonHuman.format(data);
document.getElementById('%s').appendChild(node);
});
""" % (json_str, uuid_str),
raw=True)
def add_toc(): # pragma: no cover
"""Add a dynamic table of contents to an ipython notebook.
Any heading element (h1, h2, ...) in the DOM will add a link to the table of
contents. The easiest way to add the headers is via IPythons markdown cells.
Any edits or deletes of these cells will automatically be reflected in the
generated table of contents.
Usage::
from flowly.ipy import add_toc
add_toc()
"""
from IPython.display import display_javascript, Javascript
display_javascript(Javascript(js_source))
def prepareSparkStatus():
style = "background-color: rgba(255,255,255,0.9); z-index:100;" +\
"position: fixed;" +\
"left: 0; right: 0; bottom: 0; height: 45px;" +\
"padding: 10px"
js = """
if (typeof(window.myTimers) == "undefined") {
window.myTimers = []
}
$("#sparkStatusFooter").remove()
$('body').append('<div id="sparkStatusFooter" style="%s"></div>');
""" % style
display_javascript(Javascript(js))
def loadNVD3(nvd3version="1.8.2", d3version="3.5.17"):
folder = os.path.dirname(__file__)
with open(os.path.join(folder, "../js", "loadLibraries.js"), "r") as fd:
loadLibraries = fd.read()
js = """
(function() {
var loadLibraries = %s
loadLibraries("%s", "%s", function(msg) { element.append("<div>" + msg + "</div>"); },
function(msg) { element.append("<div style='color:red'>Error: " + msg + "</div>"); })
})();
""" % (loadLibraries, d3version, nvd3version)
display_javascript(Javascript(js))
def iPythonize():
utils.setStyle()
for capture in utils.captures: capture.register()
ExtensionManager(get_ipython()).load_extension("ROOTaaS.iPyROOT.cppmagic")
ExtensionManager(get_ipython()).load_extension("ROOTaaS.iPyROOT.dclmagic")
# Make sure clike JS lexer is loaded
display.display_javascript("require(['codemirror/mode/clike/clike'], function(Clike) { console.log('ROOTaaS - C++ CodeMirror module loaded'); });", raw=True)
# Define highlight mode for %%cpp and %%dcl magics
display.display_javascript(utils.jsMagicHighlight.format(cppMIME = utils.cppMIME), raw=True)
ROOT.toCpp = utils.toCpp
ROOT.enableJSVis = utils.enableJSVis
ROOT.disableJSVis = utils.disableJSVis
#ROOT.toCpp()
utils.welcomeMsg()
def export(self, value=None):
if self._dirty:
self._update_table()
base_url = REMOTE_URL
div_id = str(uuid.uuid4())
grid_options = self.grid_options
grid_options["editable"] = False
raw_html = SLICK_GRID_CSS.format(div_id=div_id, cdn_base_url=base_url)
raw_js = SLICK_GRID_JS.format(
cdn_base_url=base_url,
div_id=div_id,
data_frame_json=self._df_json,
column_types_json=self._column_types_json,
options_json=json.dumps(grid_options),
)
display_html(raw_html, raw=True)
display_javascript(raw_js, raw=True)
def _ipython_display_(self):
f = StringIO()
# filename = os.path.join(base_path, "cube.png")
if self.data is not None:
cube_png(self.data, file=f)
else:
self.subspace_gridded.cube_png(file=f)
# cube64 = "'data:image/png;base64," + b64encode(file(filename).read()) + "'"
cube64 = "'data:image/png;base64," + b64encode(f.getvalue()).decode("ascii") + "'"
# display_javascript("""
# window.cube_src = 'data:image/png;base64,%s';
# """ % (cube64, colormap64), raw=True)
self.id = id = uuid.uuid1()
display_html("<canvas id='{id}' width=512 height=512 style='display: inline;'/>".format(**locals()), raw=True)
display_javascript(""" $('#%s').vr(
$.extend({cube:%s, colormap:window.colormap_src}, %s)
)
""" % (id, cube64, json.dumps(self.settings)), raw=True)
def ____ipython_display_(self):
# base64 = file(os.path.join(base_path, "data.png")).read().encode("base64").replace("\n", "")
# base64_colormap = file(os.path.join(base_path, "colormap.png")).read().encode("base64").replace("\n", "")
# print base64[:10]
# code = "base64 = '" + base64 + "'; base64_colormap = '" + base64_colormap + "';"
display_javascript(open(os.path.join(base_path, "all.js")).read(), raw=True)
display_javascript(file(os.path.join(base_path, "vaex_volumerendering.js")).read(), raw=True)
display_html(file(os.path.join(base_path, "snippet.js")).read(), raw=True)
html1 = file(os.path.join(base_path, "snippet.html")).read()
display_html(html1, raw=True)
# print "ok"
display_html("""<div>BLAAT</div> """, raw=True)
if 0:
js1 = file(os.path.join(base_path, "snippet.js")).read()
js2 = file(os.path.join(base_path, "vaex_volumerendering.js")).read()
js_lib = file(os.path.join(base_path, "all.js")).read()
html1 = file(os.path.join(base_path, "snippet.html")).read()
HTML("<script>" + js_lib + "\n" + code + "</script>" + "<script>" + js2 + "</script>" + html1 + js1)
def set_default_indent(num_spaces):
"""Only takes effect for new cells.
"""
from IPython.display import Javascript, display_javascript
display_javascript(Javascript('''
(function() {
"use strict";
if(require('base/js/namespace').notebook._fully_loaded){
run();
}
else{
require('base/js/events').on('notebook_loaded.Notebook', run);
}
function run() {
require("notebook/js/cell").Cell.options_default.cm_config.indentUnit = %s;
}
})()
''' % json.dumps(num_spaces)))
def _ipython_display_(self):
try:
column_types_json = json.dumps(self.column_types)
data_frame_json = self.df_copy.to_json(orient='records', date_format='iso', double_precision=self.precision)
if qgrid.remote_mode:
cdn_base_url = "https://rawgit.com/quantopian/qgrid/master/nbextensions/qgridjs"
else:
cdn_base_url = "/nbextensions/qgridjs"
raw_html = SLICK_GRID_CSS.format(div_id=self.div_id, cdn_base_url=cdn_base_url)
raw_js = SLICK_GRID_JS.format(cdn_base_url=cdn_base_url,
div_id=self.div_id,
data_frame_json=data_frame_json,
column_types_json=column_types_json)
display_html(raw_html, raw=True)
display_javascript(raw_js, raw=True)
except Exception, err:
display_html('ERROR: {}'.format(str(err)), raw=True)
def export(self, value=None):
self.update_table()
self.remote_js = True
div_id = str(uuid.uuid4())
grid_options = json.loads(self.grid_options)
grid_options['editable'] = False
raw_html = SLICK_GRID_CSS.format(
div_id=div_id,
cdn_base_url=self._cdn_base_url,
)
raw_js = SLICK_GRID_JS.format(
cdn_base_url=self._cdn_base_url,
div_id=div_id,
data_frame_json=self._df_json,
column_types_json=self._column_types_json,
options_json=json.dumps(grid_options),
)
display_html(raw_html, raw=True)
display_javascript(raw_js, raw=True)
def update_view_after_filter(self):
# trigger an update of the df json
self._bz_data_changed()
self.remote_js = True
div_id = str(uuid.uuid4())
grid_options = json.loads(self.grid_options)
grid_options['editable'] = False
raw_html = SLICK_GRID_CSS.format(
div_id=div_id,
cdn_base_url=self._cdn_base_url,
)
raw_js = SLICK_GRID_JS.format(
cdn_base_url=self._cdn_base_url,
div_id=div_id,
data_frame_json=self._df_json,
column_types_json=self._column_types_json,
options_json=json.dumps(grid_options),
)
clear_output()
display_html(raw_html, raw=True)
display_javascript(raw_js, raw=True)
def coffeescript(self, line, cell):
opts = parse_argstring(self.coffeescript, line)
ps = subprocess.Popen(('coffee','-sc'), stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
ps.stdin.write(cell)
ps.stdin.close()
return_code = ps.wait()
output = ps.stdout.read()
if return_code!=0:
print(ps.stderr.read())
return
if opts.verbose:
pretty = highlight(output, self.lexer, HtmlFormatter(full=True))
display.display_html("%s" % (pretty), raw=True)
return display.display_javascript(output, raw=True)
def _ipython_display_(self):
display_javascript(open(os.path.join(base_path, "glMatrix-0.9.5.min.js")).read(), raw=True)
display_javascript(open(os.path.join(base_path, "volumerenderer.js")).read(), raw=True)
# cube64 = b64encode(file(os.path.join(base_path, "cube.png")).read())
colormap64 = b64encode(open(os.path.join(base_path, "colormap.png"), "rb").read()).decode("ascii")
src = """
window.colormap_src = 'data:image/png;base64,%s';
""" % (colormap64,)
# print(src)
display_javascript(src, raw=True)
js_code = "window.shader_cache = [];\n"
for name in ["cube", "texture", "volr"]:
for type in ["fragment", "vertex"]:
text = open(os.path.join(base_path, "shaders", name + "-" + type + ".shader")).read()
text = text.replace("\n", "\\n").replace("'", "\\'")
js_code += "window.shader_cache['{name}_{type}'] = '{text}';\n".format(**locals())
display_javascript(js_code, raw=True)
from ._tqdm_gui import tgrange
from ._tqdm_pandas import tqdm_pandas
from ._main import main
from ._version import __version__ # NOQA
from ._tqdm import TqdmTypeError, TqdmKeyError, TqdmDeprecationWarning
try:
from IPython import get_ipython
from IPython.terminal.interactiveshell import TerminalInteractiveShell as TIShell
ip = get_ipython()
if ip is not None and not isinstance(ip, TIShell):
# Then we might be in ipython notebook. Check.
from IPython import display
# WARNING: terrible hack below
display.display_javascript("""IPython.notebook.kernel.execute(
'from IPython import get_ipython;get_ipython().has_js=True');""",
raw=True)
try:
from ipywidgets import FloatProgress, Text
except ImportError:
from IPython.html.widgets import FloatProgress, Text
except (ImportError, AssertionError):
# Not using IPython notebook. Default to text displays
pass
__all__ = ['tqdm', 'tqdm_gui', 'trange', 'tgrange', 'tqdm_pandas',
'tqdm_notebook', 'tnrange', 'main',
'TqdmTypeError', 'TqdmKeyError', 'TqdmDeprecationWarning',
'_tqdm', '_tqdm_notebook', '__version__']
def patch(force=False):
# return
global patched
if not patched or force:
display_javascript(open(os.path.join(base_path, "bqplot_ext.js")).read(), raw=True)
patched = True
def nbtoc(line):
"""add a table of contents to an IPython Notebook"""
display_html(nbtoc_html, raw=True)
display_javascript(nbtoc_js, raw=True)
def _remove(self):
display_javascript(Javascript(
"""var elem = document.getElementById('{id}'); elem.parentNode.removeChild(elem);""".format(id = self.bar_id)))
def _update(self):
display_javascript(Javascript("$('progress#{id}').val('{progress}')"\
.format(id = self.bar_id, progress = self.progress)))
def gist(line=''):
display_javascript("IPython.gist_button.publish_gist()", raw=True)
def _ipython_display_(self):
display_html(HTML(self.genhtml(refresh=False)))
from IPython.display import Javascript,display_javascript
a = Javascript('jump(\'#endofpage\')')
display_javascript(a)
def _ipython_display_(self):
json_data = json.dumps({'already': self.already_run, 'to_run': self.to_run})
display_html('<div id="{}" style="height: 300px; width:80%;" data-already-run="{}" data-to-run="{}"></div><script>window.turtle("{}");</script>'.format(self.uuid, self.already_run, self.to_run, self.uuid), raw=True)
display_javascript('alert("hi!"); console.log({})'.format(json_data))
$([IPython.events]).on('status_started.Kernel notebook_loaded.Notebook', launch_first_cell);
</script>
<p>Press this button to show/hide the code used in the notebook:
<input type="button" class="ui-button ui-widget ui-state-default \
ui-corner-all ui-button-text-only" value="Hide input" id="onoff" \
onclick="onoff();"></p>
"""
hide_outside_ipython = """<script type=text/javascript>
$(document).ready(function (){if(!("IPython" in window)){onoff();}})
</script>"""
# In order to make the notebooks readable through nbviewer we want to hide the
# code by default. However the same code is executed by the students, and in
# that case we don't want to hide the code. So we check if the code is executed
# by one of the mooc developers. Here we do by simply checking for some files that
# belong to the internal mooc repository, but are not published.
# This is a temporary solution, and should be improved in the long run.
if os.path.exists(os.path.join(module_dir, os.path.pardir, 'scripts')):
nb_html_header += hide_outside_ipython
display_html(display.HTML(nb_html_header))
with open(os.path.join(module_dir, 'make_toc.js')) as f:
js = f.read()
js += "$([IPython.events]).on('status_started.Kernel notebook_loaded.Notebook', table_of_contents);"
display.display_javascript(display.Javascript(js))
def secnum(line):
"""add a table of contents to an IPython Notebook"""
display_javascript(secnum_js, raw=True)
# Copyright 2016 The Data Incubator
# ihtml is distributed under the terms of the BSD 3-Clause License
# https://github.com/thedataincubator/ihtml
from IPython.display import display_javascript
from .ihtmlmagic import IHtmlMagics
get_ipython().register_magics(IHtmlMagics)
display_javascript("""
function add_highlight_mode(mode, pattern) {
var modes = Jupyter.CodeCell.options_default.highlight_modes;
var mode_name = 'magic_' + mode;
if (!modes[mode_name])
modes[mode_name] = {};
if (!modes[mode_name]['reg'])
modes[mode_name]['reg'] = [];
modes[mode_name]['reg'].push(pattern);
}
add_highlight_mode('html', /^%%ihtml/);
add_highlight_mode('javascript', /^%%jsdoc/);
add_highlight_mode('css', /^%%cssdoc/);
""", raw=True)
The tests in the notebooks rely on the `LAST_QUERY` variable, which is updated by the `%%sparql` magic after every query.
This variable contains the full query used (`LAST_QUERY["query"]`), the endpoint it was sent to (`LAST_QUERY["endpoint"]`), and a dictionary with the response of the endpoint (`LAST_QUERY["results"]`).
For convenience, the results are also given as tuples (`LAST_QUERY["tuples"]`), and as a dictionary of of `{column:[values]}` (`LAST_QUERY["columns"]`).
'''
from IPython.core.magic import (register_line_magic, register_cell_magic,
register_line_cell_magic)
from IPython.display import HTML, display, Image, display_javascript
from urllib.request import Request, urlopen
from urllib.parse import quote_plus, urlencode
from urllib.error import HTTPError
import json
import sys
js = "IPython.CodeCell.options_default.highlight_modes['magic_sparql'] = {'reg':[/^%%sparql/]};"
display_javascript(js, raw=True)
def send_query(query, endpoint):
FORMATS = ",".join(["application/sparql-results+json", "text/javascript", "application/json"])
data = {'query': query}
# b = quote_plus(query)
r = Request(endpoint,
data=urlencode(data).encode('utf-8'),
headers={'content-type': 'application/x-www-form-urlencoded',
'accept': FORMATS},
method='POST')
res = urlopen(r)
data = res.read().decode('utf-8')
