Class BaseSessionAbstract

constructor

• new BaseSession(config): BaseSession

• Parameters

  • config: IBaseSessionConfig

  Returns BaseSession

Optional activeRequest

Optional activeRequester

changingLanguage

config

Optional startupScript

kernelStatus

• get kernelStatus(): KernelStatus

• The current status of the kernel.

  Returns KernelStatus
• set kernelStatus(status): void

• The current status of the kernel.

  Parameters

  • status: KernelStatus

  Returns void

kernelStatusChanged

• get kernelStatusChanged(): ISignal<ISession, KernelStatus>

• A signal emitted when the kernel status changes.

  Returns ISignal<ISession, KernelStatus>

language

• get language(): KernelLanguage

• The language of the session.

  Returns KernelLanguage
• set language(language): void

• The language of the session.

  Parameters

  • language: KernelLanguage

  Returns void

serverStatus

• get serverStatus(): ServerStatus

• The current status of the server.

  Returns ServerStatus
• set serverStatus(status): void

• The current status of the server.

  Parameters

  • status: ServerStatus

  Returns void

serverStatusChanged

• get serverStatusChanged(): ISignal<ISession, ServerStatus>

• A signal emitted when the session status changes.

  Returns ISignal<ISession, ServerStatus>

Abstract changeLanguage

• changeLanguage(request): Promise<IKernelConnection>

• Request that the session change the language it is executing in.

  Parameters

  • request: {
        request: KernelLanguage;
        requester?: IRequester;
        type?: changeLanguage;
    }

    the request to queue

    • request: KernelLanguage

    • Optional requester?: IRequester

    • Optional type?: changeLanguage

  Returns Promise<IKernelConnection>

  a promise that resolves with the new kernel

Abstract clearState

• clearState(request, delegate): Promise<void>

• Clear the kernel state.

  Parameters

  • request: {
        request?: void;
        requester?: IRequester;
        type?: clearState;
    }

    • Optional request?: void

    • Optional requester?: IRequester

    • Optional type?: clearState

  • delegate: PromiseDelegate<void>

  Returns Promise<void>

Abstract connect

• connect(): Promise<void>

• Connect to the server.

  Returns Promise<void>

Abstract disconnect

• disconnect(): void

• Disconnect from the server.

  Returns void

Abstract execute

• execute(request, delegate): IOutputAdapterFuture

• Execute a request on a kernel and return an IOutputAdapterFuture.

  Parameters

  • request: {
        request: {
            allow_stdin?: boolean;
            code: string;
            silent?: boolean;
            stop_on_error?: boolean;
            store_history?: boolean;
            user_expressions?: JSONObject;
        };
        requester?: IRequester;
        type?: execute;
    }

    the request to execute

    • request: {
          allow_stdin?: boolean;
          code: string;
          silent?: boolean;
          stop_on_error?: boolean;
          store_history?: boolean;
          user_expressions?: JSONObject;
      }

      • Optional allow_stdin?: boolean

        Whether to allow stdin requests. The default is true.

      • code: string

        The code to execute.

      • Optional silent?: boolean

        Whether to execute the code as quietly as possible. The default is false.

      • Optional stop_on_error?: boolean

        Whether to the abort execution queue on an error. The default is false.

      • Optional store_history?: boolean

        Whether to store history of the execution. The default true if silent is False. It is forced to false if silent is true.

      • Optional user_expressions?: JSONObject

        A mapping of names to expressions to be evaluated in the kernel's interactive namespace.

    • Optional requester?: IRequester

    • Optional type?: execute

  • delegate: PromiseDelegate<void>

    a delegate to resolve the promise made to the requester

  Returns IOutputAdapterFuture

  an IOutputAdapterFuture that can be used to react to output messages

Abstract interrupt

• interrupt(): Promise<void>

• Interrupt the kernel.

  Returns Promise<void>

joinQueue

• joinQueue<T>(request): Promise<QueuedReturn<T>>

• Join the queue to execute a request.

  The queue is a list of execution requests as well as kernel language changes. The queue will accept requests from up to two cells at a time: the current cell and the next cell. If a third cell joins the queue, any requests from the second cell will be dropped. The queue will otherwise execute requests in order.

  Type Parameters

  • T extends SessionRequest

  Parameters

  • request: T

    the request to execute

  Returns Promise<QueuedReturn<T>>

  a promise that resolves when the request is complete, or rejects if the kernel dies, the connection is lost, or the request is dropped from the queue.