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