def install_kernel(cmd):
# Install the kernel spec when we install the package
from ipykernel import kernelspec
from jupyter_client.kernelspec import KernelSpecManager
kernel_name = 'geonotebook%i' % sys.version_info[0]
path = os.path.join(tempfile.mkdtemp(suffix='_kernels'), kernel_name)
try:
os.makedirs(path)
except OSError:
pass
kernel_dict = {
'argv': kernelspec.make_ipkernel_cmd(mod='geonotebook'),
'display_name': 'Geonotebook (Python %i)' % sys.version_info[0],
'language': 'python',
}
with open(os.path.join(path, 'kernel.json'), 'w') as fh:
json.dump(kernel_dict, fh, indent=1)
ksm = KernelSpecManager()
ksm.install_kernel_spec(path,
kernel_name=kernel_name,
user=False,
prefix=sys.prefix)
shutil.rmtree(path)
def setUp(self):
self.env_patch = test_env()
self.env_patch.start()
self.addCleanup(self.env_patch.stop)
self.km, self.kc = start_new_kernel(kernel_cmd=make_ipkernel_cmd())
self.addCleanup(self.kc.close)
self.addCleanup(self.kc.shutdown_or_terminate)
def t_start_new_kernel(self):
km, kc = yield from start_new_kernel(make_ipkernel_cmd(),
startup_timeout=5)
try:
self.assertTrue((yield from km.is_alive()))
self.assertTrue(kc.is_alive())
finally:
kc.shutdown_or_terminate()
def test_make_ipkernel_cmd():
cmd = make_ipkernel_cmd()
nt.assert_equal(cmd, [
sys.executable,
'-m',
'ipykernel',
'-f',
'{connection_file}'
])
def test_make_ipkernel_cmd():
cmd = make_ipkernel_cmd()
nt.assert_equal(cmd, [
sys.executable,
'-m',
'ipykernel_launcher',
'-f',
'{connection_file}'
])
def test_make_ipkernel_cmd():
cmd = make_ipkernel_cmd()
assert cmd == [
sys.executable,
'-m',
'ipykernel_launcher',
'-f',
'{connection_file}'
]
def get_kernel_dict(extra_arguments=None):
""" Construct dict for kernel.json.
"""
mod = 'flowgraph.kernel'
return {
'argv': make_ipkernel_cmd(mod, extra_arguments=extra_arguments),
'display_name': 'Python %i [flowgraph]' % sys.version_info[0],
'language': 'python',
}
async def test_get_connect_info(asyncio_patch):
launcher = SubprocessKernelLauncher(make_ipkernel_cmd(), os.getcwd())
info, km = await launcher.launch()
try:
assert set(info.keys()) == {
'ip', 'transport',
'hb_port', 'shell_port', 'stdin_port', 'iopub_port', 'control_port',
'key', 'signature_scheme',
}
finally:
await km.kill()
await km.cleanup()
def setUp(self):
self.env_patch = test_env()
self.env_patch.start()
self.addCleanup(self.env_patch.stop)
# Start a client in a new thread, put received messages in queues.
launcher = SubprocessKernelLauncher(make_ipkernel_cmd(), cwd='.')
connection_info, km = launcher.launch()
self.kc = ClientInThread(connection_info, manager=km)
self.received = {'shell': Queue(), 'iopub': Queue()}
self.kc.start()
if not self.kc.kernel_responding.wait(10.0):
raise RuntimeError("Failed to start kernel client")
self.kc.add_handler(self._queue_msg, {'shell', 'iopub'})
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 t_get_connect_info(self):
launcher = AsyncSubprocessKernelLauncher(make_ipkernel_cmd(),
os.getcwd())
info, km = yield from launcher.launch()
try:
self.assertEqual(
set(info.keys()), {
'ip',
'transport',
'hb_port',
'shell_port',
'stdin_port',
'iopub_port',
'control_port',
'key',
'signature_scheme',
})
finally:
yield from km.kill()
yield from km.cleanup()
def make_asynckernel_cmd():
return make_ipkernel_cmd(mod='jupytergl.kernel')
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)
"License :: OSI Approved :: BSD License",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
],
)
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", "*")),
)
data_files=[],
url=URL,
download_url=URL,
license=LICENSE,
platforms=["Any"],
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', '*')),
def assert_kernel_dict(d):
assert d['argv'] == make_ipkernel_cmd()
assert d['display_name'] == 'Python %i' % sys.version_info[0]
assert d['language'] == 'python'
def assert_kernel_dict_with_profile(d):
assert d["argv"] == make_ipkernel_cmd(
extra_arguments=["--profile", "test"])
assert d["display_name"] == "Python %i (ipykernel)" % sys.version_info[0]
assert d["language"] == "python"
def assert_kernel_dict(d):
assert d["argv"] == make_ipkernel_cmd()
assert d["display_name"] == "Python %i (ipykernel)" % sys.version_info[0]
assert d["language"] == "python"
def test_make_ipkernel_cmd():
cmd = make_ipkernel_cmd()
assert cmd == [
sys.executable, "-m", "ipykernel_launcher", "-f", "{connection_file}"
]
def assert_kernel_dict(d):
nt.assert_equal(d['argv'], make_ipkernel_cmd())
nt.assert_equal(d['display_name'], 'Python %i' % sys.version_info[0])
nt.assert_equal(d['language'], 'python')
def assert_kernel_dict_with_profile(d):
nt.assert_equal(d['argv'],
make_ipkernel_cmd(extra_arguments=["--profile", "test"]))
assert d['display_name'] == 'Python %i' % sys.version_info[0]
assert d['language'] == 'python'
def assert_kernel_dict(d):
nt.assert_equal(d['argv'], make_ipkernel_cmd())
nt.assert_equal(d['display_name'], 'Python %i' % sys.version_info[0])
nt.assert_equal(d['language'], 'python')
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', '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 assert_kernel_dict_with_profile(d):
nt.assert_equal(d['argv'], make_ipkernel_cmd(
extra_arguments=["--profile", "test"]))
nt.assert_equal(d['display_name'], 'Python %i' % sys.version_info[0])
nt.assert_equal(d['language'], 'python')
def assert_kernel_dict(d):
assert d['argv'] == make_ipkernel_cmd()
assert d['display_name'] == 'Python %i' % sys.version_info[0]
assert d['language'] == 'python'
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"}
)
