Class JupyterSession

A Jupyter server session.

Hierarchy

BaseJupyterSession
- JupyterSession

Implements

Constructors

`Protected` constructor

new JupyterSession(config, log): JupyterSession
Parameters
- config: IJupyterSessionConfig
- log: ILogger
Returns JupyterSession
Overrides BaseJupyterSession.constructor
- Defined in src/session/jupyter-session.ts:26

Properties

`Protected` _kernelStatus

_kernelStatus: KernelStatus = KernelStatus.disconnected

`Protected` _kernelStatusChanged

_kernelStatusChanged: Signal<ISession, KernelStatus> = ...

`Protected` _language

_language: KernelLanguage = KernelLanguage.r

`Protected` _serverStatus

_serverStatus: ServerStatus = ServerStatus.disconnected

`Protected` _serverStatusChanged

_serverStatusChanged: Signal<ISession, ServerStatus> = ...

`Optional` activeRequest

activeRequest?: SessionRequest

The request that is currently active in the queue.

`Optional` activeRequester

activeRequester?: IRequester

The object whose request is currently being processed.

changingLanguage

changingLanguage: boolean = false

Whether the session is currently changing language.

config

config: IBaseSessionConfig

context

context: SessionContext

The current session context.

`Protected` isReady

isReady: boolean = false

`Protected` kernelManager

kernelManager: KernelManager = null

log

log: ILogger

`Protected` queue

queue: QueuedRequest[] = []

`Protected` `Optional` readyDelegate

readyDelegate?: PromiseDelegate<void>

`Optional` serverSettings

serverSettings?: ISettings

The settings for the server connection.

`Protected` serviceManager

serviceManager: ServiceManager = null

`Protected` sessionManager

sessionManager: SessionManager = null

`Protected` specsManager

specsManager: KernelSpecManager = null

`Optional` startupScript

startupScript?: {
python: string;
r: string;
}

Code to run every time a kernel is (re)started.

Type declaration

python: string
r: string

`Static` `Private` _instance

_instance: JupyterSession

Accessors

kernelStatus

get kernelStatus(): KernelStatus
The current status of the kernel.

Returns KernelStatus
Implementation of ISession.kernelStatus

Inherited from BaseJupyterSession.kernelStatus
- Defined in src/core/session.ts:82
set kernelStatus(status): void
The current status of the kernel.
Parameters
- status: KernelStatus
Returns void
Implementation of ISession.kernelStatus

Inherited from BaseJupyterSession.kernelStatus
- Defined in src/core/session.ts:86

kernelStatusChanged

get kernelStatusChanged(): ISignal<ISession, KernelStatus>
A signal emitted when the kernel status changes.

Returns ISignal<ISession, KernelStatus>
Implementation of ISession.kernelStatusChanged

Inherited from BaseJupyterSession.kernelStatusChanged
- Defined in src/core/session.ts:93

language

get language(): KernelLanguage
The language of the session.

Returns KernelLanguage
Implementation of ISession.language

Inherited from BaseJupyterSession.language
- Defined in src/core/session.ts:98
set language(language): void
The language of the session.
Parameters
- language: KernelLanguage
Returns void
Implementation of ISession.language

Inherited from BaseJupyterSession.language
- Defined in src/core/session.ts:102

serverStatus

get serverStatus(): ServerStatus
The current status of the server.

Returns ServerStatus
Implementation of ISession.serverStatus

Inherited from BaseJupyterSession.serverStatus
- Defined in src/core/session.ts:66
set serverStatus(status): void
The current status of the server.
Parameters
- status: ServerStatus
Returns void
Implementation of ISession.serverStatus

Inherited from BaseJupyterSession.serverStatus
- Defined in src/core/session.ts:70

serverStatusChanged

get serverStatusChanged(): ISignal<ISession, ServerStatus>
A signal emitted when the session status changes.

Returns ISignal<ISession, ServerStatus>
Implementation of ISession.serverStatusChanged

Inherited from BaseJupyterSession.serverStatusChanged
- Defined in src/core/session.ts:77

Methods

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
Implementation of ISession.changeLanguage

Inherited from BaseJupyterSession.changeLanguage
- Defined in src/session/base-jupyter-session.ts:160

checkConnection

checkConnection(settings): Promise<boolean>
Determine if the server is available by pinging it for a status.
Parameters
- settings: ISettings
  
  the server settings to use
Returns Promise<boolean>
Inherited from BaseJupyterSession.checkConnection
- Defined in src/session/base-jupyter-session.ts:240

`Protected` clearQueue

clearQueue(message): void
Clear the queue and reject all promises with the given message.
Parameters
- message: string
  
  the message to reject with
Returns void
Inherited from BaseJupyterSession.clearQueue
- Defined in src/core/session.ts:218

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>
Implementation of ISession.clearState

Inherited from BaseJupyterSession.clearState
- Defined in src/session/base-jupyter-session.ts:222

connect

connect(): Promise<void>
Connect to the session.

Returns Promise<void>
Implementation of ISession.connect

Inherited from BaseJupyterSession.connect
- Defined in src/session/base-jupyter-session.ts:56

disconnect

disconnect(): Promise<void>
Disconnect from the session.

Returns Promise<void>
Implementation of ISession.disconnect

Inherited from BaseJupyterSession.disconnect
- Defined in src/session/base-jupyter-session.ts:146

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
Implementation of ISession.execute

Inherited from BaseJupyterSession.execute
- Defined in src/session/base-jupyter-session.ts:181

`Protected` executeQueue

executeQueue(): Promise<void>
Execute the next request in the queue.

Returns Promise<void>
Inherited from BaseJupyterSession.executeQueue
- Defined in src/core/session.ts:130

interrupt

interrupt(): Promise<void>
Interrupt the kernel.

Returns Promise<void>
Implementation of ISession.interrupt

Inherited from BaseJupyterSession.interrupt
- Defined in src/session/base-jupyter-session.ts:207

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.
Implementation of ISession.joinQueue

Inherited from BaseJupyterSession.joinQueue
- Defined in src/core/session.ts:107

`Protected` makeKernelSpecs

makeKernelSpecs(language): {
language: KernelLanguage;
name: KernelName;
}
Resolve the kernel specs for a given language.
Parameters
- language: KernelLanguage
  
  the language to get the kernel name for
Returns {
language: KernelLanguage;
name: KernelName;
}
the kernel name
- language: KernelLanguage
- name: KernelName
Inherited from BaseJupyterSession.makeKernelSpecs
- Defined in src/session/base-jupyter-session.ts:301

`Protected` makeServerSettings

makeServerSettings(settings): ISettings
Complete and validate a partial configuration object for a Jupyter server connection.
Parameters
- settings: IJupyterServerConfig
Returns ISettings
a complete configuration object
Inherited from BaseJupyterSession.makeServerSettings
- Defined in src/session/base-jupyter-session.ts:288

`Protected` makeSessionContext

makeSessionContext(config, serverSettings): SessionContext
Make a session context.
Parameters
- config: IBaseSessionConfig
  
  the configuration for this session context
- serverSettings: ISettings
Returns SessionContext
a session context
Inherited from BaseJupyterSession.makeSessionContext
- Defined in src/session/base-jupyter-session.ts:254

`Protected` runStartup

runStartup(readyDelegate?, requester?): Promise<void>
Parameters
- Optional readyDelegate: PromiseDelegate<void>
- Optional requester: IRequester
Returns Promise<void>
Inherited from BaseJupyterSession.runStartup
- Defined in src/core/session.ts:198

`Static` getInstance

getInstance(config, logger): JupyterSession
Parameters
- config: IJupyterSessionConfig
- logger: ILogger
Returns JupyterSession
- Defined in src/session/jupyter-session.ts:21

Class JupyterSession

Hierarchy

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

Protected constructor

Parameters

config: IJupyterSessionConfig

log: ILogger

Returns JupyterSession

Properties

Protected _kernelStatus

Protected _kernelStatusChanged

Protected _language

Protected _serverStatus

Protected _serverStatusChanged

Optional activeRequest

Optional activeRequester

changingLanguage

config

context

Protected isReady

Protected kernelManager

log

Protected queue

Protected Optional readyDelegate

Optional serverSettings

Protected serviceManager

Protected sessionManager

Protected specsManager

Optional startupScript

Type declaration

python: string

r: string

Static Private _instance

Accessors

kernelStatus

Returns KernelStatus

Parameters

status: KernelStatus

Returns void

kernelStatusChanged

Returns ISignal<ISession, KernelStatus>

language

Returns KernelLanguage

Parameters

language: KernelLanguage

Returns void

serverStatus

Returns ServerStatus

Parameters

status: ServerStatus

Returns void

serverStatusChanged

Returns ISignal<ISession, ServerStatus>

Methods

changeLanguage

Parameters

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

request: KernelLanguage

Optional requester?: IRequester

Optional type?: changeLanguage

Returns Promise<IKernelConnection>

checkConnection

Parameters

settings: ISettings

Returns Promise<boolean>

Protected clearQueue

Parameters

message: string

Returns void

clearState

Parameters

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

Optional request?: void

Optional requester?: IRequester

`Protected` constructor

`Protected` _kernelStatus

`Protected` _kernelStatusChanged

`Protected` _language

`Protected` _serverStatus

`Protected` _serverStatusChanged

`Optional` activeRequest

`Optional` activeRequester

`Protected` isReady

`Protected` kernelManager

`Protected` queue

`Protected` `Optional` readyDelegate

`Optional` serverSettings

`Protected` serviceManager

`Protected` sessionManager

`Protected` specsManager

`Optional` startupScript

`Static` `Private` _instance

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

`Optional` requester?: IRequester

`Optional` type?: changeLanguage

`Protected` clearQueue

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

`Optional` request?: void

`Optional` requester?: IRequester

`Optional` type?: clearState

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

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

`Optional` allow_stdin?: boolean

`Optional` silent?: boolean

`Optional` stop_on_error?: boolean

`Optional` store_history?: boolean

`Optional` user_expressions?: JSONObject

`Optional` requester?: IRequester

`Optional` type?: execute

`Protected` executeQueue

`Protected` makeKernelSpecs

Returns {
language: KernelLanguage;
name: KernelName;
}

`Protected` makeServerSettings

`Protected` makeSessionContext

`Protected` runStartup

`Optional` readyDelegate: PromiseDelegate<void>

`Optional` requester: IRequester

`Static` getInstance