Interface ISessionContext

A context object to manage a widget's kernel session connection.

Notes

The current session connection is .session, the current session's kernel connection is .session.kernel. For convenience, we proxy several kernel connection and session connection signals up to the session context so that you do not have to manage slots as sessions and kernels change. For example, to act on whatever the current kernel's iopubMessage signal is producing, connect to the session context .iopubMessage signal.

interface ISessionContext {
    connectionStatusChanged: ISignal<
        ISessionContext,
        Kernel.ConnectionStatus,
    >;
    disposed: ISignal<ISessionContext, void>;
    hasNoKernel: boolean;
    iopubMessage: ISignal<
        ISessionContext,
        KernelMessage.IMessage<KernelMessage.MessageType>,
    >;
    isDisposed: boolean;
    isReady: boolean;
    isRestarting: boolean;
    isTerminating: boolean;
    kernelChanged: ISignal<
        ISessionContext,
        IChangedArgs<
            null
            | Kernel.IKernelConnection,
            null | Kernel.IKernelConnection,
            "kernel",
        >,
    >;
    kernelDisplayName: string;
    kernelDisplayStatus: KernelDisplayStatus;
    kernelManager?: Kernel.IManager;
    kernelPreference: IKernelPreference;
    kernelPreferenceChanged: ISignal<
        ISessionContext,
        IChangedArgs<IKernelPreference, IKernelPreference, string>,
    >;
    name: string;
    path: string;
    pendingInput: boolean;
    prevKernelName: string;
    propertyChanged: ISignal<ISessionContext, "name" | "type" | "path">;
    ready: Promise<void>;
    session: null | Session.ISessionConnection;
    sessionChanged: ISignal<
        ISessionContext,
        IChangedArgs<
            null
            | Session.ISessionConnection,
            null | Session.ISessionConnection,
            "session",
        >,
    >;
    sessionManager: Session.IManager;
    specsManager: KernelSpec.IManager;
    statusChanged: ISignal<ISessionContext, Kernel.Status>;
    type: string;
    unhandledMessage: ISignal<
        ISessionContext,
        KernelMessage.IMessage<KernelMessage.MessageType>,
    >;
    changeKernel(
        options?: Partial<Kernel.IModel>,
    ): Promise<null | Kernel.IKernelConnection>;
    dispose(): void;
    initialize(): Promise<boolean>;
    restartKernel(): Promise<void>;
    shutdown(): Promise<void>;
    startKernel(): Promise<boolean>;
}

Hierarchy

IObservableDisposable
- ISessionContext

Implemented by

SessionContext

Properties

`Readonly`connectionStatusChanged

connectionStatusChanged: ISignal<ISessionContext, Kernel.ConnectionStatus>

A signal emitted when the kernel connection status changes, proxied from the session connection.

`Readonly`disposed

disposed: ISignal<ISessionContext, void>

A signal emitted when the object is disposed.

`Readonly`hasNoKernel

hasNoKernel: boolean

Whether the kernel is "No Kernel" or not.

Notes

As the displayed name is translated, this can be used directly.

`Readonly`iopubMessage

iopubMessage: ISignal<
ISessionContext,
KernelMessage.IMessage<KernelMessage.MessageType>,
>

A signal emitted for a kernel messages, proxied from the session connection.

`Readonly`isDisposed

isDisposed: boolean

Test whether the object has been disposed.

Notes

This property is always safe to access.

`Readonly`isReady

isReady: boolean

Whether the session context is ready.

`Readonly`isRestarting

isRestarting: boolean

Whether the session context is restarting.

`Readonly`isTerminating

isTerminating: boolean

Whether the session context is terminating.

`Readonly`kernelChanged

kernelChanged: ISignal<
    ISessionContext,
    IChangedArgs<
        null
        | Kernel.IKernelConnection,
        null | Kernel.IKernelConnection,
        "kernel",
    >,
>

A signal emitted when the kernel changes, proxied from the session connection.

`Readonly`kernelDisplayName

kernelDisplayName: string

The sensible display name for the kernel, or translated "No Kernel"

Notes

This is at this level since the underlying kernel connection does not have access to the kernel spec manager.

`Readonly`kernelDisplayStatus

kernelDisplayStatus: KernelDisplayStatus

A sensible status to display

Notes

This combines the status and connection status into a single status for the user.

`Optional` `Readonly`kernelManager

kernelManager?: Kernel.IManager

The kernel manager

Notes

In the next major version of this interface, a kernel manager is required.

kernelPreference

kernelPreference: IKernelPreference

The kernel preference for starting new kernels.

`Readonly`kernelPreferenceChanged

kernelPreferenceChanged: ISignal<
ISessionContext,
IChangedArgs<IKernelPreference, IKernelPreference, string>,
>

Signal emitted if the kernel preference changes.

`Readonly`name

name: string

The session name.

Notes

Typically .session.name should be used. This attribute is useful if there is no current session.

`Readonly`path

path: string

The session path.

Notes

Typically .session.path should be used. This attribute is useful if there is no current session.

`Readonly`pendingInput

pendingInput: boolean

A flag indicating if session is has pending input, proxied from the session connection.

`Readonly`prevKernelName

prevKernelName: string

The previous kernel name.

`Readonly`propertyChanged

propertyChanged: ISignal<ISessionContext, "name" | "type" | "path">

A signal emitted when a session property changes, proxied from the session connection.

`Readonly`ready

ready: Promise<void>

A promise that is fulfilled when the session context is ready.

session

session: null | Session.ISessionConnection

The current session connection.

`Readonly`sessionChanged

sessionChanged: ISignal<
    ISessionContext,
    IChangedArgs<
        null
        | Session.ISessionConnection,
        null | Session.ISessionConnection,
        "session",
    >,
>

A signal emitted when the session connection changes.

`Readonly`sessionManager

sessionManager: Session.IManager

The session manager used by the session.

`Readonly`specsManager

specsManager: KernelSpec.IManager

The kernel spec manager

`Readonly`statusChanged

statusChanged: ISignal<ISessionContext, Kernel.Status>

A signal emitted when the kernel status changes, proxied from the session connection.

`Readonly`type

type: string

The session type.

Notes

Typically .session.type should be used. This attribute is useful if there is no current session.

`Readonly`unhandledMessage

unhandledMessage: ISignal<
ISessionContext,
KernelMessage.IMessage<KernelMessage.MessageType>,
>

A signal emitted for an unhandled kernel message, proxied from the session connection.

Methods

changeKernel

changeKernel(
options?: Partial<Kernel.IModel>,
): Promise<null | Kernel.IKernelConnection>
Change the kernel associated with the session.
Parameters
- Optionaloptions: Partial<Kernel.IModel>
  The optional kernel model parameters to use for the new kernel.
Returns Promise<null | Kernel.IKernelConnection>
A promise that resolves with the new kernel connection.
- Defined in packages/apputils/src/sessioncontext.tsx:246

dispose

dispose(): void
Dispose of the resources held by the object.

Notes
If the object's dispose method is called more than once, all calls made after the first will be a no-op.

Undefined Behavior
It is undefined behavior to use any functionality of the object after it has been disposed unless otherwise explicitly noted.

Returns void
Inherited from IObservableDisposable.dispose
- Defined in node_modules/@lumino/disposable/types/index.d.ts:28

initialize

initialize(): Promise<boolean>
Initialize the session context.

Returns Promise<boolean>
A promise that resolves with whether to ask the user to select a kernel.

Notes
This includes starting up an initial kernel if needed.
- Defined in packages/apputils/src/sessioncontext.tsx:52

restartKernel

restartKernel(): Promise<void>
Restart the current Kernel.

Returns Promise<void>
A promise that resolves when the kernel is restarted.
- Defined in packages/apputils/src/sessioncontext.tsx:230

shutdown

shutdown(): Promise<void>
Kill the kernel and shutdown the session.

Returns Promise<void>
A promise that resolves when the session is shut down.
- Defined in packages/apputils/src/sessioncontext.tsx:237

startKernel

startKernel(): Promise<boolean>
Starts new Kernel.

Returns Promise<boolean>
Whether to ask the user to pick a kernel.
- Defined in packages/apputils/src/sessioncontext.tsx:223

Interface ISessionContext

Notes

Hierarchy

Implemented by

Index

Properties

Methods

Properties

ReadonlyconnectionStatusChanged

Readonlydisposed

ReadonlyhasNoKernel

Notes

ReadonlyiopubMessage

ReadonlyisDisposed

Notes

ReadonlyisReady

ReadonlyisRestarting

ReadonlyisTerminating

ReadonlykernelChanged

ReadonlykernelDisplayName

Notes

ReadonlykernelDisplayStatus

Notes

Optional ReadonlykernelManager

Notes

kernelPreference

ReadonlykernelPreferenceChanged

Readonlyname

Notes

Readonlypath

Notes

ReadonlypendingInput

ReadonlyprevKernelName

ReadonlypropertyChanged

Readonlyready

session

ReadonlysessionChanged

ReadonlysessionManager

ReadonlyspecsManager

ReadonlystatusChanged

Readonlytype

Notes

ReadonlyunhandledMessage

Methods

changeKernel

Parameters

Returns Promise<null | Kernel.IKernelConnection>

dispose

Notes

Undefined Behavior

Returns void

initialize

Returns Promise<boolean>

Notes

restartKernel

Returns Promise<void>

shutdown

Returns Promise<void>

startKernel

Returns Promise<boolean>

Settings

On This Page

`Readonly`connectionStatusChanged

`Readonly`disposed

`Readonly`hasNoKernel

`Readonly`iopubMessage

`Readonly`isDisposed

`Readonly`isReady

`Readonly`isRestarting

`Readonly`isTerminating

`Readonly`kernelChanged

`Readonly`kernelDisplayName

`Readonly`kernelDisplayStatus

`Optional` `Readonly`kernelManager

`Readonly`kernelPreferenceChanged

`Readonly`name

`Readonly`path

`Readonly`pendingInput

`Readonly`prevKernelName

`Readonly`propertyChanged

`Readonly`ready

`Readonly`sessionChanged

`Readonly`sessionManager

`Readonly`specsManager

`Readonly`statusChanged

`Readonly`type

`Readonly`unhandledMessage