This code imports a module, declares variables and functions, and defines four functions (do_execute, do_display, do_shutdown, do_complete) that handle different types of requests, increment a counter, store functions and send responses, and execute promise chains to perform tasks and send replies.

This code sets up a system to handle different types of requests, including execution, display, shutdown, and completion, and defines functions to send responses and execute tasks accordingly. The code also uses promise chains to manage asynchronous operations and send replies to the kernel.

Run example

npm run import -- "TODO: wire meta kernel"

TODO: wire meta kernel

var importer = require('../Core');
var extend = importer.import("extend prototype")

var count = 0;
var responders = [];

function do_execute(kernel, request) {
    // TODO: do some magics here?
    var execution_count = ++count;
    responders[execution_count] = kernel.do_respond;
    kernel.do_respond({status: {execution_state: 'busy'}});
    kernel.do_respond({execute_input: {
        execution_count: request.execution_count,
        code: request.content.code,
    }})
    var result;
    return Promise.resolve()
        .then(() => kernel.do_execute(request.content))
        .then(r => result = r)
        .then(() => kernel.do_respond({status: {execution_state: 'idle'}}))
        .then(() => kernel.do_respond({execute_reply: {
            status: 'ok',
            execution_count: request.execution_count,
            payload: [], // TODO(NR) not implemented,
            user_expressions: {}, // TODO(NR) not implemented,
        }}))
        .then(() => kernel.do_respond({execute_result: {
            execution_count: request.execution_count,
            data: {'text/plain': result + ''},
            metadata: {}
        }}))
}

function do_display(kernel, request) {
    kernel.do_respond(request.display_id
        ? {update_display_data: {
            metadata: {},
            data: request.content,
            transient: request.display_id}}
        : {display_data: {metadata: {}, data: request.content}})
}

function do_shutdown(kernel, request) {
    kernel.do_respond({status: {execution_state: 'busy'}});
    return Promise.resolve()
        .then(() => kernel.do_shutdown(request.content))
        .then(r => result = r)
        // TODO: some sort of shutdown scripting
        .then(() => kernel.do_respond({status: {execution_state: 'idle'}}))
        .then(() => kernel.do_respond({shutdown_reply: request.content}))
}

function do_complete(kernel, request) {
    kernel.do_respond({status: {execution_state: 'busy'}});
    var result;
    return Promise.resolve()
        .then(() => kernel.do_complete(request.content))
        .then(r => result = r)
        .then(() => kernel.do_respond({status: {execution_state: 'idle'}}))
        .then(() => kernel.do_respond({complete_reply: {
            matches: result.completion.list,
            cursor_start: result.completion.cursorStart,
            cursor_end: result.completion.cursorEnd,
            status: "ok",
        }}))
}

function do_history(kernel, request) {
    kernel.do_respond({status: {execution_state: 'busy'}});
    return Promise.resolve()
        .then(() => kernel.do_history(request.content))
        .then(r => result = r)
        .then(() => kernel.do_respond({status: {execution_state: 'idle'}}))
        .then(() => kernel.do_respond({history_reply: {
            history: [] // TODO
        }}))
}

function do_is_complete(kernel, request) {
    kernel.do_respond({status: {execution_state: 'busy'}});
    var result;
    return Promise.resolve()
        .then(() => kernel.do_is_complete(request.content))
        .then(r => result = r)
        .then(() => kernel.do_respond({status: {execution_state: 'idle'}}))
        .then(() => kernel.do_respond({is_complete_reply: {
            status: (result ? 'complete': 'incomplete'),
            indent: ''
        }}))
}

function do_inspect(kernel, request) {
    var execution_count = ++count;
    kernel.do_respond({status: {execution_state: 'busy'}});
    var result;
    return Promise.resolve()
        .then(() => kernel.do_inspect(request.content))
        .then(r => result = r)
        .then(() => kernel.do_respond({status: {execution_state: 'idle'}}))
        // TODO: move this to do_display method?
        .then(() => result.inspection
              ? result.inspection.type + ': ' + result.inspection.string
              : result.doc.usage
                  ? result.doc.usage + '\n\n' + result.doc.description
                  : result)
        // TODO: use error for all promises
        .then(() => kernel.do_respond({inspect_reply: {
            found: true,
            data: {'text/plain': result, 'text/html': `<pre>${result}</pre>`},
            metadata: {},
            status: "ok",
        }}))
        .catch(e => kernel.do_respond({inspect_reply: {
            status: "error",
            execution_count: execution_count,
            ename: result.error.ename,
            evalue: result.error.evalue,
            traceback: result.error.traceback,
        }}))
}

function wireMetaKernel(meta_kernel) {
    return extend(metaKernelInterface(session), wireMetaKernel);
}

wireMetaKernel.prototype = {
    shutdown_request: do_shutdown,
    is_complete_request: do_is_complete,
    execute_request: do_execute,
    complete_request: do_complete,
    history_request: do_history,
    inspect_request: do_inspect,
};

module.exports = {
    wireMetaKernel
}

const { createInterface } = require('../Core');

const metaKernelInterface = {
  execute_request: (metaKernel, request) => metaKernel.executeRequest(request),
  is_complete_request: (metaKernel, request) => metaKernel.isCompleteRequest(request),
  complete_request: (metaKernel, request) => metaKernel.completeRequest(request),
  history_request: (metaKernel, request) => metaKernel.historyRequest(request),
  inspect_request: (metaKernel, request) => metaKernel.inspectRequest(request),
  shutdown_request: (metaKernel, request) => metaKernel.shutdownRequest(request)
};

class WireMetaKernel {
  constructor(kernel) {
    this.kernel = kernel;
    this.executionCount = 0;
  }

  executeRequest(request) {
    this.kernel.execute(request.content);
    return this.doRespond({ status: { execution_state: 'idle' } });
  }

  isCompleteRequest(request) {
    const result = this.kernel.isComplete(request.content);
    return this.doRespond({ is_complete_reply: { status: (result? 'complete': 'incomplete'), indent: '' } });
  }

  completeRequest(request) {
    this.kernel.complete(request.content);
    return this.doRespond({ complete_reply: {
      matches: this.kernel.completion.list,
      cursor_start: this.kernel.completion.cursorStart,
      cursor_end: this.kernel.completion.cursorEnd,
      status: "ok",
    }});
  }

  historyRequest(request) {
    return this.doRespond({ status: { execution_state: 'idle' } })
     .then(() => this.kernel.history(request.content))
     .then(r => this.doRespond({ history_reply: {
        history: r
      }}));
  }

  inspectRequest(request) {
    return this.doRespond({ status: { execution_state: 'busy' } })
     .then(() => this.kernel.inspect(request.content))
     .then(r => this.doRespond({ status: { execution_state: 'idle' } }))
     .then(() => {
        const inspectionType = r.inspection? r.inspection.type : '';
        const inspectionString = r.inspection? r.inspection.string : '';
        const docUsage = r.doc? r.doc.usage : '';
        const docDescription = r.doc? r.doc.description : '';
        return this.doRespond({ inspect_reply: {
          found: true,
          data: { 'text/plain': r, 'text/html': `
${r}
` },
          metadata: {},
          status: "ok",
        }})
       .catch(e => this.doRespond({ inspect_reply: {
          status: "error",
          execution_count: this.executionCount,
          ename: e.ename,
          evalue: e.evalue,
          traceback: e.traceback,
        }}));
      });
  }

  shutdownRequest(request) {
    this.kernel.shutdown(request.content);
    return this.doRespond({ status: { execution_state: 'idle' } })
     .then(() => this.doRespond({ shutdown_reply: request.content }));
  }

  doRespond(response) {
    this.kernel.doRespond(response);
    return Promise.resolve();
  }
}

function createWireMetaKernel(kernel) {
  return new WireMetaKernel(kernel);
}

module.exports = {
  createWireMetaKernel,
  metaKernelInterface,
};

Code Breakdown

Importing Modules

var importer = require('../Core');
var extend = importer.import('extend prototype')

This code imports a module from a file named Core located two directories above the current file. The importer object has a method import() which is used to import specific functions from the Core module. In this case, the extend function is imported.

Variables and Functions

var count = 0;
var responders = [];

function do_execute(kernel, request) {... }
function do_display(kernel, request) {... }
function do_shutdown(kernel, request) {... }
function do_complete(kernel, request) {... }

Three variables are declared: count initialized to 0 and responders an empty array. Four functions are defined:

• do_execute(): handles execution requests
• do_display(): handles display requests
• do_shutdown(): handles shutdown requests
• do_complete(): handles completion requests

Function Breakdown

do_execute() Function

function do_execute(kernel, request) {
    //...
}

This function takes two parameters: kernel and request. It:

1. Increments the count variable.
2. Stores the kernel.do_respond function in the responders array at the current count index.
3. Sends a response to the kernel indicating a busy state.
4. Sends an execute input request to the kernel.
5. Executes a promise chain that:
   • Calls kernel.do_execute() with the request content.
   • Stores the result in the result variable.
   • Sends a response to the kernel indicating an idle state.
   • Sends an execute reply response to the kernel.
   • Sends an execute result response to the kernel.

do_display() Function

function do_display(kernel, request) {
    //...
}

This function takes two parameters: kernel and request. It:

1. If the request has a display ID, sends an update display data response to the kernel.
2. Otherwise, sends a display data response to the kernel.

do_shutdown() Function

function do_shutdown(kernel, request) {
    //...
}

This function takes two parameters: kernel and request. It:

1. Sends a response to the kernel indicating a busy state.
2. Executes a promise chain that:
   • Calls kernel.do_shutdown() with the request content.
   • Stores the result in the result variable.
   • Sends a response to the kernel indicating an idle state.
   • Sends a shutdown reply response to the kernel.

do_complete() Function

function do_complete(kernel, request) {
    //...
}

This function takes two parameters: kernel and request. It:

1. Sends a response to the kernel indicating a busy state.
2. Executes a promise chain that:
   • Calls kernel.do_complete() with the request.
   • Stores the result in the result variable.
   • Sends a response to the kernel indicating an idle state.
   • Sends a complete reply response to the kernel.