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'
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')
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"} )