def _connect_to_kernel(self, args):
"""Start new or connect to existing `Jupyter` kernel
Parameters
----------
args: argparse.ArgumentParser parsed arguments
Arguments given to `JKernel` command through `neovim`.
Returns
-------
kc: jupyter_client.KernelClient
The kernel client in charge of negotiating communication between
`neovim` and the `Jupyter` kernel.
new_kernel_started: bool
Flag to keep track of new / existing kernel.
"""
logging.debug('ARGS {}'.format(args))
if args.existing is not None:
connection_file = jc.find_connection_file(filename=args.existing)
logging.debug('CONNECT {}, {}'.format(connection_file,
args.existing))
km = jc.KernelManager(connection_file=connection_file)
km.load_connection_file()
new_kernel_started = False
else:
km = jc.KernelManager()
km.start_kernel()
new_kernel_started = True
kc = km.client()
kc.start_channels()
return kc, new_kernel_started
def start_cb(update, context):
tgid = update.message.from_user.id
kernel = config.kernel
if tgid in config.kernel_dict:
update.message.reply_text('Kernel already started')
elif config.num_kernels >= 50:
update.message.reply_text('Too many users, please come back later!')
else:
config.num_kernels += 1
update.message.reply_text('Starting kernel...')
wd = '/home/jovyan/work/' + str(tgid)
os.makedirs(wd, exist_ok=True)
if kernel == 'python':
pass
elif kernel == 'octave':
pkgd = wd + '/octave_packages'
os.makedirs(pkgd, exist_ok=True)
rwd = wd
km = jupyter_client.KernelManager(kernel_name=config.kernel_name)
km.start_kernel(cwd=rwd)
cl = km.blocking_client()
_init_commands(cl, rwd, kernel)
t = Timer(config.timer_value, stop_kernel, [tgid])
t.start()
config.kernel_dict[tgid] = (km, cl, t, kernel)
update.message.reply_text(kernel + ' is ready!')
def handle_connection(json):
# print('**************Session ID:', request.sid)
global session_count
#start the kernel for this user
# kernel_id = kernel_man.start_kernel()
kernel_manager = jc.KernelManager()
kernel_manager.start_kernel()
# sessionmap[request.sid]['kernel_client'] = kernel_manager.blocking_client()
global admin_sid
if json['data'] == 'admin':
emit('connected_users', len(sessionmap))
admin_sid = request.sid
else:
print('******** Initial Convo: ', init_conversation)
sessionmap[request.sid] = {
'conversation': list(init_conversation),
'kernel_client': kernel_manager.blocking_client()
}
sessionmap[request.sid]['kernel_client'].start_channels()
session_ids.append(request.sid)
emit('uname', 'user' + str(len(sessionmap)))
emit('init_convo', init_conversation)
if admin_sid != '':
emit('new_user', 'user' + str(len(sessionmap)), room=admin_sid)
return
def prepare_executor(self):
self.parse_output = True
self.km = jupyter_client.KernelManager(kernel_name=self.kernel_name)
self.km.start_kernel()
self.kc = self.km.client()
self.kc.start_channels()
self.kc.allow_stdin = False
self.kc.wait_for_ready()
def __init__(self, kernel_name):
self.kernel = jupyter_client.KernelManager(kernel_name=kernel_name)
self.pending = {}
with open(
os.path.join(os.path.dirname(__file__),
"message-schema.json")) as f:
message_schema = json.load(f)
jsonschema.Draft7Validator.check_schema(message_schema)
self.message_validator = jsonschema.Draft7Validator(message_schema)
def start_kernel(self):
if not hasattr(self.application, 'kernel'):
self.kernel_manager = jupyter_client.KernelManager()
self.kernel_manager.kernel_name = self.kernel_name
self.kernel_manager.start_kernel()
self.application.kernel_manager = self.kernel_manager
self.application.kernel = self.kernel_manager.client()
self.application.kernel.start_channels()
self.kernel = self.application.kernel
self.kernel_started = True
def start(name):
global client
global km
km = jupyter_client.KernelManager(kernel_name=name)
km.start_kernel()
client = km.blocking_client()
msg = client.get_iopub_msg()
while not (msg['msg_type'] == 'status'
and msg['content']['execution_state'] == 'starting'):
msg = client.get_iopub_msg()
def start_kernel(self):
self.kernel_manager = jupyter_client.KernelManager()
self.kernel_manager.kernel_name = self.kernel_name
self.kernel_manager.start_kernel()
self.client = self.kernel_manager.blocking_client()
self.client.start_channels()
try:
self.client.wait_for_ready()
except RuntimeError:
pass
else:
query_id = self.client.comm_info()
with self.active_queries_lock:
self.active_queries[query_id] = None
def get_client(self, kernel_name, **kernel_args):
if kernel_name not in self.clients:
vim.command(f'echo "Starting kernel: {kernel_name}"')
km = jupyter_client.KernelManager(kernel_name=kernel_name)
km.start_kernel(**kernel_args)
kc = km.client()
kc.start_channels()
try:
kc.wait_for_ready(timeout=60)
except RuntimeError:
kc.stop_channels()
km.shutdown_kernel()
raise
self.clients[kernel_name] = (km, kc)
return self.clients[kernel_name][1]
def startup_connection(self, ipykernel_filename):
self.kernel_manager = jupyter_client.KernelManager(
connection_file=jupyter_client.find_connection_file(
ipykernel_filename,
path=[
".",
path.join("/", "run", "user", str(getuid()), "jupyter"),
path.join(path.expanduser("~"), ".ipython",
"profile_default", "security")
],
))
self.kernel_manager.load_connection_file()
self.client = self.kernel_manager.blocking_client()
self.client.start_channels()
reply = self.client.get_shell_msg()
def start_cb(update, context):
tgid = update.message.from_user.id
if len(context.args)==0:
update.message.reply_text('Usage: /start <kernel>\nList of available kernels %s' % (config.kernels,))
else:
kernel = context.args[0]
if not kernel in config.kernels:
update.message.reply_text('Kernel %s not available\nList of available kernels %s' % (kernel, config.kernels))
elif tgid in config.kernel_dict:
update.message.reply_text('Kernel already started')
elif config.num_kernels >=50:
update.message.reply_text('Too many users, please come back later!')
else:
config.num_kernels += 1
update.message.reply_text('Starting kernel...')
wd = '/home/jovyan/work/' + str(tgid)
os.makedirs(wd, exist_ok=True)
if kernel=='python':
pass
elif kernel == 'R':
rlibd = wd + '/R-libs'
os.makedirs(rlibd, exist_ok=True)
elif kernel == 'octave':
pkgd = wd + '/octave_packages'
os.makedirs(pkgd, exist_ok=True)
rwd = wd
t = Timer(config.timer_value, stop_kernel, [tgid])
t.start()
km = jupyter_client.KernelManager(kernel_name = config.kernel_name[kernel])
km.start_kernel(cwd=rwd)
cl = km.blocking_client()
_init_commands(cl, rwd, kernel)
config.kernel_dict[tgid] = (km, cl, t, kernel)
update.message.reply_text(kernel + ' is ready!')
def run_notebook(nb, name):
print(name, end=" ")
k = jupyter_client.KernelManager()
k.start_kernel(stderr=open(os.devnull, 'w'))
assert k.is_alive()
c = k.blocking_client()
c.execute("import sys; sys.path.append('..')")
for i, cell in enumerate(nb.cells):
if cell.cell_type == 'code':
print(i, end=" ")
c.execute(cell.source, stop_on_error=True, silent=False)
reply = c.get_shell_msg()
content = reply['content']
if reply['msg_type'] == "execute_reply" and content[
'status'] != 'ok':
try:
ename = content['ename']
evalue = content['evalue']
except:
raise RuntimeError("Unknown error in cell {} of {}".format(
i, name))
raise RuntimeError(
"Notebook error {} {} at cell {} of {}".format(
ename, evalue, i, name))
if not k.is_alive():
raise RuntimeError("Unknown error in cell {} of {}".format(
i, name))
print()
assert k.is_alive()
k.shutdown_kernel()
del k
pass
########################
## v4
## - Start an async KernelClient (NEW for jupyter_client 6.0.0)
## - define an async loop waiting on iopub_msg
## - Run a command, and log the incoming iopub messages.
########################
logging.basicConfig(level=logging.DEBUG, filename='client.log')
ksm = jc.kernelspec.KernelSpecManager()
kspecs = ksm.find_kernel_specs()
kernel_names = kspecs.keys()
kerMan = jc.KernelManager(kernel_name='python3')
kerMan.start_kernel()
# because there is no `KernelManager.async_client()`
# have to construct `AsyncKernelClient` ourself, yuck
kw = {}
kw.update(kerMan.get_connection_info(session=True))
kw.update(dict(connection_file=kerMan.connection_file, parent=kerMan))
aclient = jc.AsyncKernelClient(**kw)
aclient.start_channels()
async def arecv():
logging.debug("arecv called")
def setUp(self):
self.maxDiff = 8192
self._kernel = jupyter_client.KernelManager()
self._kernel.start_kernel()
self.kernel_name = self._kernel.kernel_name
def __init__(self):
self.kernel_manager = jupyter_client.KernelManager(
kernel_name='iqsharp')
try:
pyexe
except:
pyexe = subprocess.getoutput('which python')
sys.executable = pyexe
multiprocessing.set_executable(pyexe)
multiprocessing.set_start_method('spawn')
import jupyter_client
import time
print(jupyter_client.kernelspec.find_kernel_specs())
print(jupyter_client.kernelspec.get_kernel_spec('python3').to_dict())
km = jupyter_client.KernelManager(kernel_name='sjk-singular')
km.start_kernel()
print(km.is_alive())
kc = km.client()
kc.start_channels()
try:
kc.wait_for_ready(timeout=60)
except RuntimeError:
kc.stop_channels()
km.shutdown_kernel()
raise
def post(self):
code = self.get_argument("code")
kernel_manager = jupyter_client.KernelManager()
kernel_manager.name = "python3"
kernel_manager.start_kernel()
kernel = kernel_manager.client()
kernel.start_channels()
msg_id = kernel.execute(code)
# print(msg_id)
while True:
# print('stuck here')
try:
msg = kernel.shell_channel.get_msg(Integer(10, config=True))
# print(msg)
except Empty:
# print('Empty')
pass
# This indicates that something bad happened, as AFAIK this should return...
# self.log.error("Timeout waiting for execute reply")
# raise KnitpyException("Timeout waiting for execute reply.")
if msg['parent_header'].get('msg_id') == msg_id:
# It's finished, and we got our reply, so next look at the results
break
else:
# print('something')
# not our reply
# self.log.debug("Discarding message from a different client: %s" % msg)
continue
# Now look at the results of our code execution and earlier completion requests
# We handle messages until the kernel indicates it's ide again
status_idle_again = False
while True:
# print('stuck here now')
try:
msg = kernel.get_iopub_msg(Integer(10, config=True))
# print('doing something')
except Exception:
# print('Empty')
pass
# There should be at least some messages: we just executed code!
# The only valid time could be when the timeout happened too early (aka long
# running code in the document) -> we handle that below
# self.log.warn("Timeout waiting for expected IOPub output")
break
# print(msg['parent_header'].get('msg_id') != msg_id)
if msg['parent_header'].get('msg_id') != msg_id:
if msg['parent_header'].get(
u'msg_type') != u'is_complete_request':
# print('output')
pass
# not an output from our execution and not one of the complete_requests
# self.log.debug("Discarding output from a different client: %s" % msg)
else:
# print('something too')
pass
# complete_requests are ok
continue
# Here we have some message which corresponds to our code execution
msg_type = msg['msg_type']
content = msg['content']
# print('Out')
# The kernel indicates some status: executing -> idle
if msg_type == 'status':
if content['execution_state'] == 'idle':
# When idle, the kernel has executed all input
status_idle_again = True
break
else:
# the "starting execution" messages
continue
elif msg_type == 'clear_output':
# we don't handle that!?
# self.log.debug("Discarding unexpected 'clear_output' message: %s" % msg)
continue
## So, from here on we have a messages with real content
print(content)
self.write(json.dumps(content, ensure_ascii=False))
if not status_idle_again:
pass
