def install_kernelspec(self):
from ipykernel.kernelspec import write_kernel_spec
from jupyter_client.kernelspec import KernelSpecManager
kernel_spec_manager = KernelSpecManager()
log.info('Writing kernel spec')
kernel_spec_path = write_kernel_spec(overrides=kernel_json)
log.info('Installing kernel spec ' + kernel_spec_path)
try:
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=self.user)
except Exception as e:
log.error(str(e.args))
log.error('Failed to install kernel spec')
else:
return
# retry with not self.user
log.info('Retry install kernel spec')
try:
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=not self.user)
except Exception as e:
log.error(str(e.args))
log.error('Failed to install kernel spec')
def createKernelSpec(self):
try:
libFiles = os.listdir("{0}/python/lib".format(self.spark_home))
py4j_zip = list(filter( lambda filename: "py4j" in filename, libFiles))[0]
except:
print('Unable to find py4j in SPARK_HOME: {0}'.format(self.spark_home))
self.exit(1)
overrides={
"display_name": self.kernelName,
"argv": [
"python",
"-m",
"ipykernel",
"-f",
"{connection_file}"
],
"env": {
"PIXIEDUST_HOME": self.pixiedust_home,
"SCALA_HOME": "{0}".format(self.scala_home),
"SPARK_HOME": "{0}".format(self.spark_home),
"PYTHONPATH": "{0}/python/:{0}/python/lib/{1}".format(self.spark_home, py4j_zip),
"PYTHONSTARTUP": "{0}/python/pyspark/shell.py".format(self.spark_home),
"PYSPARK_SUBMIT_ARGS": "--driver-class-path {0}/data/libs/* --master local[10] pyspark-shell".format(self.pixiedust_home),
"SPARK_DRIVER_MEMORY":"10G",
"SPARK_LOCAL_IP":"127.0.0.1"
}
}
path = write_kernel_spec(overrides=overrides)
dest = KernelSpecManager().install_kernel_spec(path, kernel_name=''.join(ch for ch in self.kernelName if ch.isalnum()), user=True)
# cleanup afterward
shutil.rmtree(path)
return dest
def install_kernelspec(self):
from ipykernel.kernelspec import write_kernel_spec
from jupyter_client.kernelspec import KernelSpecManager
from wolfram_kernel.wolfram_kernel import WolframKernel
kernel_json = WolframKernel.kernel_json
kernel_js = WolframKernel.kernel_js
kernel_spec_manager = KernelSpecManager()
log.info('Writing kernel spec')
kernel_spec_path = write_kernel_spec(overrides=kernel_json)
with open(kernel_spec_path + "/kernel.js", "w") as jsfile:
jsfile.write(kernel_js)
log.info('Installing kernel spec')
try:
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=user)
except:
log.error('Failed to install kernel spec in ' +
kernel_spec_path)
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=not user)
def install_kernelspec(self):
from ipykernel.kernelspec import write_kernel_spec
from jupyter_client.kernelspec import KernelSpecManager
kernel_spec_manager = KernelSpecManager()
log.info('Writing kernel spec')
kernel_spec_path = write_kernel_spec(overrides=kernel_json)
log.info('Installing kernel spec ' + kernel_spec_path)
try:
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=self.user)
except Exception as e:
log.error(str(e.args))
log.error('Failed to install kernel spec')
else:
return
# retry with not self.user
log.info('Retry install kernel spec')
try:
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=not self.user)
except Exception as e:
log.error(str(e.args))
log.error('Failed to install kernel spec')
def _install_kernels():
# Install echo and ipython kernels - should be done after env patch
kernel_json = {
'argv': [sys.executable,
'-m', 'jupyterlab.tests.echo_kernel',
'-f', '{connection_file}'],
'display_name': "Echo Kernel",
'language': 'echo'
}
paths = jupyter_core.paths
kernel_dir = pjoin(paths.jupyter_data_dir(), 'kernels', 'echo')
os.makedirs(kernel_dir)
with open(pjoin(kernel_dir, 'kernel.json'), 'w') as f:
f.write(json.dumps(kernel_json))
ipykernel_dir = pjoin(paths.jupyter_data_dir(), 'kernels', 'ipython')
write_kernel_spec(ipykernel_dir)
def _install_default_kernels(self):
# Install echo and ipython kernels - should be done after env patch
self._install_kernel(kernel_name="echo",
kernel_spec={
'argv': [
sys.executable, '-m',
'jupyterlab.tests.echo_kernel', '-f',
'{connection_file}'
],
'display_name':
"Echo Kernel",
'language':
'echo'
})
paths = jupyter_core.paths
ipykernel_dir = pjoin(paths.jupyter_data_dir(), 'kernels', 'ipython')
write_kernel_spec(ipykernel_dir)
def _install_kernels():
# Install echo and ipython kernels - should be done after env patch
kernel_json = {
'argv': [
sys.executable,
'-m', 'jupyterlab.tests.echo_kernel',
'-f', '{connection_file}'
],
'display_name': "Echo Kernel",
'language': 'echo'
}
paths = jupyter_core.paths
kernel_dir = pjoin(paths.jupyter_data_dir(), 'kernels', 'echo')
os.makedirs(kernel_dir)
with open(pjoin(kernel_dir, 'kernel.json'), 'w') as f:
f.write(json.dumps(kernel_json))
ipykernel_dir = pjoin(paths.jupyter_data_dir(), 'kernels', 'ipython')
write_kernel_spec(ipykernel_dir)
def _install_default_kernels(self):
# Install echo and ipython kernels - should be done after env patch
self._install_kernel(
kernel_name="echo",
kernel_spec={
"argv": [
sys.executable,
"-m",
"jupyterlab.tests.echo_kernel",
"-f",
"{connection_file}",
],
"display_name":
"Echo Kernel",
"language":
"echo",
},
)
paths = jupyter_core.paths
ipykernel_dir = pjoin(paths.jupyter_data_dir(), "kernels", "ipython")
write_kernel_spec(ipykernel_dir)
def createKernelSpecIfNeeded(kernelName=__TEST_KERNEL_NAME__, useSpark=False):
try:
km = KernelManager(kernel_name=kernelName)
km.kernel_spec
print("Kernal already exists!")
return None
except NoSuchKernel:
print("Creating new Kernel {} target: {}".format(kernelName, useSpark))
if useSpark:
sparkHome = os.environ["SPARK_HOME"]
overrides = {
"argv":
["python", "-m", "ipykernel", "-f", "{connection_file}"],
"env": {
"SCALA_HOME":
"{0}".format(os.environ["SCALA_HOME"]),
"SPARK_HOME":
"{0}".format(sparkHome),
"PYTHONPATH":
"{0}/python/:{0}/python/lib/py4j-0.9-src.zip".format(
sparkHome),
"PYTHONSTARTUP":
"{0}/python/pyspark/shell.py".format(sparkHome),
"PYSPARK_SUBMIT_ARGS":
"--driver-class-path {0}/data/libs/* --master local[10] pyspark-shell"
.format(
os.environ.get("PIXIEDUST_HOME",
os.path.expanduser('~'))),
"SPARK_DRIVER_MEMORY":
"10G",
"SPARK_LOCAL_IP":
"127.0.0.1"
}
}
else:
overrides = {
"argv":
["python", "-m", "ipykernel", "-f", "{connection_file}"],
"env": {
"PIXIEDUST_HOME":
os.environ.get("PIXIEDUST_HOME", os.path.expanduser('~'))
}
}
path = write_kernel_spec(overrides=overrides)
dest = KernelSpecManager().install_kernel_spec(path,
kernel_name=kernelName,
user=True)
# cleanup afterward
shutil.rmtree(path)
return dest
def initialize(self, version, build_data):
here = os.path.abspath(os.path.dirname(__file__))
sys.path.insert(0, here)
from ipykernel.kernelspec import make_ipkernel_cmd, write_kernel_spec
overrides = {}
# When building a standard wheel, the executable specified in the kernelspec is simply 'python'.
if version == "standard":
overrides["metadata"] = dict(debugger=True)
argv = make_ipkernel_cmd(executable="python")
# When installing an editable wheel, the full `sys.executable` can be used.
else:
argv = make_ipkernel_cmd()
overrides["argv"] = argv
dest = os.path.join(here, "data_kernelspec")
if os.path.exists(dest):
shutil.rmtree(dest)
write_kernel_spec(dest, overrides=overrides)
def install_kernelspec(self):
from ipykernel.kernelspec import write_kernel_spec
from jupyter_client.kernelspec import KernelSpecManager
kernel_spec_manager = KernelSpecManager()
log.info('Writing kernel spec')
kernel_spec_path = write_kernel_spec(overrides=kernel_json)
log.info('Installing kernel spec')
try:
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=self.user)
except:
log.error('Failed to install kernel spec')
def install_kernelspec():
from ipykernel.kernelspec import write_kernel_spec
from jupyter_client.kernelspec import KernelSpecManager
kernel_spec_manager = KernelSpecManager()
print('Writing kernel spec')
kernel_spec_path = write_kernel_spec(overrides=kernel_json)
print('Installing kernel spec ' + kernel_spec_path)
try:
kernel_spec_manager.install_kernel_spec(
kernel_spec_path, kernel_name=kernel_json['name'], user=True)
except Exception as e:
print(str(e.args))
print('Failed to install kernel spec')
else:
return
def install_jupyter_kernelspec(self):
from ipykernel.kernelspec import write_kernel_spec
from jupyter_client.kernelspec import KernelSpecManager
kernel_json = {
'argv':
[sys.executable, '-m', 'imathics', '-f', '{connection_file}'],
'display_name': 'mathics',
'language': 'Mathematica',
'name': 'mathics',
}
kernel_spec_manager = KernelSpecManager()
log.info('Writing kernel spec')
kernel_spec_path = write_kernel_spec(overrides=kernel_json)
log.info('Installing kernel spec ' + kernel_spec_path)
try:
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=self.user)
except Exception as e:
log.error(str(e.args))
log.error('Failed to install kernel spec')
else:
return
# retry with not self.user
log.info('Retry install kernel spec')
try:
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=not self.user)
except Exception as e:
log.error(str(e.args))
log.error('Failed to install kernel spec')
def createKernelSpec(self):
try:
libFiles = os.listdir("{0}/python/lib".format(self.spark_home))
py4j_zip = list(filter( lambda filename: "py4j" in filename, libFiles))[0]
except:
print('Unable to find py4j in SPARK_HOME: {0}'.format(self.spark_home))
self.exit(1)
overrides={
"display_name": self.kernelName,
"argv": [
"python",
"-m",
"ipykernel",
"-f",
"{connection_file}"
],
"env": {
"PIXIEDUST_HOME": self.pixiedust_home,
"SCALA_HOME": "{0}".format(self.scala_home),
"SPARK_HOME": "{0}".format(self.spark_home),
"PYTHONPATH": "{0}/python/:{0}/python/lib/{1}".format(self.spark_home, py4j_zip),
"PYTHONSTARTUP": "{0}/python/pyspark/shell.py".format(self.spark_home),
"PYSPARK_SUBMIT_ARGS": "--jars {0} --driver-class-path {1} --master local[10] pyspark-shell".format(
self.sparkCloudantPath,
":".join([x for x in [self.pixiedust_home + "/data/libs/*" ,self.sparkCSVPath,self.commonsCSVPath] if x is not None]),
),
"SPARK_DRIVER_MEMORY":"10G",
"SPARK_LOCAL_IP":"127.0.0.1"
}
}
path = write_kernel_spec(overrides=overrides)
self.kernelInternalName = ''.join(ch for ch in self.kernelName if ch.isalnum()).lower()
print("self.kernelInternalName {}".format(self.kernelInternalName))
dest = KernelSpecManager().install_kernel_spec(path, kernel_name=self.kernelInternalName, user=True)
# cleanup afterward
shutil.rmtree(path)
return dest
description=DESCRIPTION,
long_description=LONG_DESCRIPTION,
long_description_content_type='text/markdown',
classifiers=CLASSIFIERS,
requires=REQUIRES,
install_requires=INSTALL_REQUIRES)
if any(a.startswith(('bdist', 'build', 'install')) for a in sys.argv):
from ipykernel.kernelspec import write_kernel_spec, make_ipkernel_cmd
argv = make_ipkernel_cmd(mod='elm_kernel', executable='python')
dest = os.path.join(here, 'data_kernelspec')
if os.path.exists(dest):
shutil.rmtree(dest)
write_kernel_spec(dest,
overrides={
'argv':
argv,
'display_name':
'ELM (Python: {} ELM: {})'.format(
sys.version_info[0], current_version)
})
setup_args['data_files'].append((
pjoin('share', 'jupyter', 'kernels', KERNEL_NAME),
glob(pjoin('data_kernelspec', '*')),
))
if __name__ == '__main__':
setup(**setup_args)
def test_write_kernel_spec_path():
path = os.path.join(tempfile.mkdtemp(), KERNEL_NAME)
path2 = write_kernel_spec(path)
assert path == path2
assert_is_spec(path)
shutil.rmtree(path)
def test_write_kernel_spec():
path = write_kernel_spec()
assert_is_spec(path)
shutil.rmtree(path)
from ipykernel.kernelspec import write_kernel_spec, make_ipkernel_cmd
install_requires = [
"enum34", "jupyter_core", "ipywidgets", "ipykernel", "IPython", "numpy",
"matplotlib"
]
distname = "bridge_kernel"
kernelname = "bridge"
setup_args = dict(name=distname,
description="Bridge Kernel for existing backends",
packages=[distname],
install_requires=install_requires)
# Kernelspec installations
dest = join(abspath(dirname(__file__)), "kernelspec_data")
if exists(dest):
shutil.rmtree(dest)
write_kernel_spec(path=dest,
overrides=dict(argv=make_ipkernel_cmd("%s.kernel" %
distname),
display_name="Bridge Kernel",
name=kernelname))
setup_args["data_files"] = [(join("share", "jupyter", "kernels",
kernelname), glob(join(dest, "*")))]
setup(**setup_args)
classifiers=[
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 3',
],
)
if any(a.startswith(('bdist', 'build', 'install')) for a in sys.argv):
from ipykernel.kernelspec import write_kernel_spec, make_ipkernel_cmd, KERNEL_NAME
argv = make_ipkernel_cmd(executable='python')
dest = os.path.join(here, 'data_kernelspec')
if os.path.exists(dest):
shutil.rmtree(dest)
write_kernel_spec(dest, overrides={'argv': argv})
setup_args['data_files'] = [
(
pjoin('share', 'jupyter', 'kernels', KERNEL_NAME),
glob(pjoin('data_kernelspec', '*')),
)
]
if __name__ == '__main__':
setup(**setup_args)
if any(arg.startswith(("bdist", "install")) for arg in sys.argv):
here = os.path.abspath(os.path.dirname(__file__))
sys.path.insert(0, here)
from ipykernel.kernelspec import write_kernel_spec, make_ipkernel_cmd
extra_arguments = ["--IPKernelApp.trio_loop=True"]
# When building a wheel, the executable specified in the kernelspec is simply "python".
if any(arg.startswith("bdist") for arg in sys.argv):
argv = make_ipkernel_cmd(executable="python", extra_arguments=extra_arguments)
# When installing from source, the full `sys.executable` can be used.
if any(arg.startswith("install") for arg in sys.argv):
argv = make_ipkernel_cmd(extra_arguments=extra_arguments)
dest = os.path.join(here, "data_kernelspec")
if os.path.exists(dest):
shutil.rmtree(dest)
write_kernel_spec(dest, overrides={"argv": argv, "display_name": DISPLAY_NAME})
resource_path = os.path.join(os.path.dirname(__file__), "trio_jupyter", "resources")
shutil.copytree(resource_path, dest, dirs_exist_ok=True)
setup_args["data_files"] = [
(
os.path.join("share", "jupyter", "kernels", KERNEL_NAME),
glob(os.path.join("data_kernelspec", "*")),
)
]
if __name__ == "__main__":
setup(**setup_args)
from os.path import join
from ipykernel.kernelspec import write_kernel_spec, make_ipkernel_cmd
if __name__ == "__main__":
argv = make_ipkernel_cmd(executable="fil-profile")
argv.insert(1, "python")
write_kernel_spec(
"data_kernelspec", overrides={"argv": argv, "display_name": "Python 3 with Fil"}
)
def test_write_kernel_spec_path():
path = os.path.join(tempfile.mkdtemp(), KERNEL_NAME)
path2 = write_kernel_spec(path)
nt.assert_equal(path, path2)
assert_is_spec(path)
shutil.rmtree(path)
packages=[distname],
install_require=["ipykernel", "mpi4py"]
)
# create kernelspec
here = os.path.abspath(os.path.dirname(__file__))
dest = os.path.join(here, "data_kernelspec")
if os.path.exists(dest):
shutil.rmtree(dest)
version = sys.version_info[0]
if nprocs > 1:
display_name = "MPI Python %d (np=%d)" % (version, nprocs)
kernel_name = "mpipython%d_np%d" % (version, nprocs)
argv = [mpirun, "-n", str(nprocs), sys.executable, "-m", "%s.%s" % (distname, distname), "-f", "{connection_file}"]
else:
display_name = "MPI Python %d" % version
kernel_name = "mpipython%d" % version
argv = [sys.executable, "-m", "%s.%s" % (distname, distname), "-f", "{connection_file}"]
overrides = {
"argv": argv,
"display_name": display_name,
"interrupt_mode": "message"
}
write_kernel_spec(dest, overrides=overrides)
setup_args["data_files"] = [(("share/jupyter/kernels/%s" % kernel_name), glob.glob("data_kernelspec/*"))]
setup(**setup_args)
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 3',
],
)
if any(a.startswith(('bdist', 'install')) for a in sys.argv):
from ipykernel.kernelspec import write_kernel_spec, make_ipkernel_cmd, KERNEL_NAME
# When building a wheel, the executable specified in the kernelspec is simply 'python'.
if any(a.startswith('bdist') for a in sys.argv):
argv = make_ipkernel_cmd(executable='python')
# When installing from source, the full `sys.executable` can be used.
if any(a.startswith('install') for a in sys.argv):
argv = make_ipkernel_cmd()
dest = os.path.join(here, 'data_kernelspec')
if os.path.exists(dest):
shutil.rmtree(dest)
write_kernel_spec(dest, overrides={'argv': argv})
setup_args['data_files'] = [(
pjoin('share', 'jupyter', 'kernels', KERNEL_NAME),
glob(pjoin('data_kernelspec', '*')),
)]
if __name__ == '__main__':
setup(**setup_args)
def test_write_kernel_spec():
path = write_kernel_spec()
assert_is_spec(path)
shutil.rmtree(path)
