@datalayer/jupyter-react 0.8.2 → 0.9.0

package/lib/components/kernel/variables/inspectorscripts.js

@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+class Languages {
+    /**
+     * Init and query script for supported languages.
+     */
+    static py_script = `import json
+import sys
+from importlib import __import__
+from IPython import get_ipython
+from IPython.core.magics.namespace import NamespaceMagics
+
+
+_jupyterlab_variableinspector_nms = NamespaceMagics()
+_jupyterlab_variableinspector_Jupyter = get_ipython()
+_jupyterlab_variableinspector_nms.shell = _jupyterlab_variableinspector_Jupyter.kernel.shell
+
+__np = None
+__pd = None
+__pyspark = None
+__tf = None
+__K = None
+__torch = None
+__ipywidgets = None
+__xr = None
+
+
+def _attempt_import(module):
+    try:
+        return __import__(module)
+    except ImportError:
+        return None
+
+
+def _check_imported():
+    global __np, __pd, __pyspark, __tf, __K, __torch, __ipywidgets, __xr
+
+    __np = _attempt_import('numpy')
+    __pd = _attempt_import('pandas')
+    __pyspark = _attempt_import('pyspark')
+    __tf = _attempt_import('tensorflow')
+    __K = _attempt_import('keras.backend') or _attempt_import('tensorflow.keras.backend')
+    __torch = _attempt_import('torch')
+    __ipywidgets = _attempt_import('ipywidgets')
+    __xr = _attempt_import('xarray')
+
+
+def _jupyterlab_variableinspector_getsizeof(x):
+    if type(x).__name__ in ['ndarray', 'Series']:
+        return x.nbytes
+    elif __pyspark and isinstance(x, __pyspark.sql.DataFrame):
+        return "?"
+    elif __tf and isinstance(x, __tf.Variable):
+        return "?"
+    elif __torch and isinstance(x, __torch.Tensor):
+        return x.element_size() * x.nelement()
+    elif __pd and type(x).__name__ == 'DataFrame':
+        return x.memory_usage().sum()
+    else:
+        return sys.getsizeof(x)
+
+
+def _jupyterlab_variableinspector_getshapeof(x):
+    if __pd and isinstance(x, __pd.DataFrame):
+        return "%d rows x %d cols" % x.shape
+    if __pd and isinstance(x, __pd.Series):
+        return "%d rows" % x.shape
+    if __np and isinstance(x, __np.ndarray):
+        shape = " x ".join([str(i) for i in x.shape])
+        return "%s" % shape
+    if __pyspark and isinstance(x, __pyspark.sql.DataFrame):
+        return "? rows x %d cols" % len(x.columns)
+    if __tf and isinstance(x, __tf.Variable):
+        shape = " x ".join([str(int(i)) for i in x.shape])
+        return "%s" % shape
+    if __tf and isinstance(x, __tf.Tensor):
+        shape = " x ".join([str(int(i)) for i in x.shape])
+        return "%s" % shape
+    if __torch and isinstance(x, __torch.Tensor):
+        shape = " x ".join([str(int(i)) for i in x.shape])
+        return "%s" % shape
+    if __xr and isinstance(x, __xr.DataArray):
+        shape = " x ".join([str(int(i)) for i in x.shape])
+        return "%s" % shape
+    if isinstance(x, list):
+        return "%s" % len(x)
+    if isinstance(x, dict):
+        return "%s keys" % len(x)
+    return None
+
+
+def _jupyterlab_variableinspector_getcontentof(x):
+    # returns content in a friendly way for python variables
+    # pandas and numpy
+    if __pd and isinstance(x, __pd.DataFrame):
+        colnames = ', '.join(x.columns.map(str))
+        content = "Columns: %s" % colnames
+    elif __pd and isinstance(x, __pd.Series):
+        content = str(x.values).replace(" ", ", ")[1:-1]
+        content = content.replace("\\n", "")
+    elif __np and isinstance(x, __np.ndarray):
+        content = x.__repr__()
+    elif __xr and isinstance(x, __xr.DataArray):
+        content = x.values.__repr__()
+    else:
+        content = str(x)
+
+    if len(content) > 150:
+        return content[:150] + " ..."
+    else:
+        return content
+
+
+def _jupyterlab_variableinspector_is_matrix(x):
+    # True if type(x).__name__ in ["DataFrame", "ndarray", "Series"] else False
+    if __pd and isinstance(x, __pd.DataFrame):
+        return True
+    if __pd and isinstance(x, __pd.Series):
+        return True
+    if __np and isinstance(x, __np.ndarray) and len(x.shape) <= 2:
+        return True
+    if __pyspark and isinstance(x, __pyspark.sql.DataFrame):
+        return True
+    if __tf and isinstance(x, __tf.Variable) and len(x.shape) <= 2:
+        return True
+    if __tf and isinstance(x, __tf.Tensor) and len(x.shape) <= 2:
+        return True
+    if __torch and isinstance(x, __torch.Tensor) and len(x.shape) <= 2:
+        return True
+    if __xr and isinstance(x, __xr.DataArray) and len(x.shape) <= 2:
+        return True
+    if isinstance(x, list):
+        return True
+    return False
+
+
+def _jupyterlab_variableinspector_is_widget(x):
+    return __ipywidgets and issubclass(x, __ipywidgets.DOMWidget)
+
+
+def _jupyterlab_variableinspector_dict_list():
+    _check_imported()
+    def keep_cond(v):
+        try:
+            obj = eval(v)
+            if isinstance(obj, str):
+                return True
+            if __tf and isinstance(obj, __tf.Variable):
+                return True
+            if __pd and __pd is not None and (
+                isinstance(obj, __pd.core.frame.DataFrame)
+                or isinstance(obj, __pd.core.series.Series)):
+                return True
+            if __xr and __xr is not None and isinstance(obj, __xr.DataArray):
+                return True
+            if str(obj)[0] == "<":
+                return False
+            if  v in ['__np', '__pd', '__pyspark', '__tf', '__K', '__torch', '__ipywidgets', '__xr']:
+                return obj is not None
+            if str(obj).startswith("_Feature"):
+                # removes tf/keras objects
+                return False
+            return True
+        except:
+            return False
+    values = _jupyterlab_variableinspector_nms.who_ls()
+    vardic = [
+        {
+            'varName': _v,
+            'varType': type(eval(_v)).__name__, 
+            'varSize': str(_jupyterlab_variableinspector_getsizeof(eval(_v))), 
+            'varShape': str(_jupyterlab_variableinspector_getshapeof(eval(_v))) if _jupyterlab_variableinspector_getshapeof(eval(_v)) else '', 
+            'varContent': str(_jupyterlab_variableinspector_getcontentof(eval(_v))), 
+            'isMatrix': _jupyterlab_variableinspector_is_matrix(eval(_v)),
+            'isWidget': _jupyterlab_variableinspector_is_widget(type(eval(_v)))
+        }
+        for _v in values if keep_cond(_v)
+    ]
+    return json.dumps(vardic, ensure_ascii=False)
+
+
+def _jupyterlab_variableinspector_getmatrixcontent(x, max_rows=10000):
+    # to do: add something to handle this in the future
+    threshold = max_rows
+
+    if __pd and __pyspark and isinstance(x, __pyspark.sql.DataFrame):
+        df = x.limit(threshold).toPandas()
+        return _jupyterlab_variableinspector_getmatrixcontent(df.copy())
+    elif __np and __pd and type(x).__name__ == "DataFrame":
+        if threshold is not None:
+            x = x.head(threshold)
+        x.columns = x.columns.map(str)
+        return x.to_json(orient="table", default_handler=_jupyterlab_variableinspector_default, force_ascii=False)
+    elif __np and __pd and type(x).__name__ == "Series":
+        if threshold is not None:
+            x = x.head(threshold)
+        return x.to_json(orient="table", default_handler=_jupyterlab_variableinspector_default, force_ascii=False)
+    elif __np and __pd and type(x).__name__ == "ndarray":
+        df = __pd.DataFrame(x)
+        return _jupyterlab_variableinspector_getmatrixcontent(df)
+    elif __tf and (isinstance(x, __tf.Variable) or isinstance(x, __tf.Tensor)):
+        df = __K.get_value(x)
+        return _jupyterlab_variableinspector_getmatrixcontent(df)
+    elif __torch and isinstance(x, __torch.Tensor):
+        df = x.cpu().numpy()
+        return _jupyterlab_variableinspector_getmatrixcontent(df)
+    elif __xr and isinstance(x, __xr.DataArray):
+        df = x.to_numpy()
+        return _jupyterlab_variableinspector_getmatrixcontent(df)
+    elif isinstance(x, list):
+        s = __pd.Series(x)
+        return _jupyterlab_variableinspector_getmatrixcontent(s)
+
+
+def _jupyterlab_variableinspector_displaywidget(widget):
+    display(widget)
+
+
+def _jupyterlab_variableinspector_default(o):
+    if isinstance(o, __np.number): return int(o)  
+    raise TypeError
+
+
+def _jupyterlab_variableinspector_deletevariable(x):
+    exec("del %s" % x, globals())
+`;
+    static r_script = `library(repr)
+
+.ls.objects = function (pos = 1, pattern, order.by, decreasing = FALSE, head = FALSE, 
+    n = 5) 
+{
+    napply <- function(names, fn) sapply(names, function(x) fn(get(x, 
+        pos = pos)))
+    names <- ls(pos = pos, pattern = pattern)
+    if (length(names) == 0) {
+        return(jsonlite::toJSON(data.frame()))
+    }
+    obj.class <- napply(names, function(x) as.character(class(x))[1])
+    obj.mode <- napply(names, mode)
+    obj.type <- ifelse(is.na(obj.class), obj.mode, obj.class)
+    obj.size <- napply(names, object.size)
+    obj.dim <- t(napply(names, function(x) as.numeric(dim(x))[1:2]))
+    obj.content <- rep("NA", length(names))
+    has_no_dim <- is.na(obj.dim)[1:length(names)]                        
+    obj.dim[has_no_dim, 1] <- napply(names, length)[has_no_dim]
+    vec <- (obj.type != "function")
+    obj.content[vec] <- napply(names[vec], function(x) toString(x, width = 154)[1])
+                      
+    obj.rownames <- napply(names, rownames)
+    has_rownames <- obj.rownames != "NULL"
+    obj.rownames <- sapply(obj.rownames[has_rownames], function(x) paste(x,
+        collapse=", "))
+    obj.rownames.short <- sapply(obj.rownames, function(x) paste(substr(x, 1, 150), "...."))
+    obj.rownames <- ifelse(nchar(obj.rownames) > 154, obj.rownames.short, obj.rownames)
+    obj.rownames <- sapply(obj.rownames, function(x) paste("Row names: ",x))
+    obj.content[has_rownames] <- obj.rownames
+                               
+                               
+    obj.colnames <- napply(names, colnames)
+    has_colnames <- obj.colnames != "NULL"
+    obj.colnames <- sapply(obj.colnames[has_colnames], function(x) paste(x, 
+        collapse = ", "))
+    obj.colnames.short <- sapply(obj.colnames, function(x) paste(substr(x, 
+        1, 150), "...."))
+    obj.colnames <- ifelse(nchar(obj.colnames) > 154, obj.colnames.short, 
+        obj.colnames)
+    obj.colnames <- sapply(obj.colnames, function(x) paste("Column names: ",x))
+                    
+    obj.content[has_colnames] <- obj.colnames
+                           
+    is_function <- (obj.type == "function")
+    obj.content[is_function] <- napply(names[is_function], function(x) paste(strsplit(repr_text(x),")")[[1]][1],")",sep=""))
+    obj.content <- unlist(obj.content, use.names = FALSE)
+    
+
+    out <- data.frame(obj.type, obj.size, obj.dim)
+    names(out) <- c("varType", "varSize", "Rows", "Columns")
+    out$varShape <- paste(out$Rows, " x ", out$Columns)
+    out$varContent <- obj.content
+    out$isMatrix <- FALSE
+    out$varName <- row.names(out)
+    out <- out[, !(names(out) %in% c("Rows", "Columns"))]
+    rownames(out) <- NULL
+    print(out)
+    if (!missing(order.by)) 
+        out <- out[order(out[[order.by]], decreasing = decreasing), 
+            ]
+    if (head) 
+        out <- head(out, n)
+    jsonlite::toJSON(out)
+}
+
+.deleteVariable <- function(x) {
+    remove(list=c(x), envir=.GlobalEnv)
+}
+    `;
+    static scripts = {
+        python3: {
+            initScript: Languages.py_script,
+            queryCommand: '_jupyterlab_variableinspector_dict_list()',
+            matrixQueryCommand: '_jupyterlab_variableinspector_getmatrixcontent',
+            widgetQueryCommand: '_jupyterlab_variableinspector_displaywidget',
+            deleteCommand: '_jupyterlab_variableinspector_deletevariable',
+        },
+        python2: {
+            initScript: Languages.py_script,
+            queryCommand: '_jupyterlab_variableinspector_dict_list()',
+            matrixQueryCommand: '_jupyterlab_variableinspector_getmatrixcontent',
+            widgetQueryCommand: '_jupyterlab_variableinspector_displaywidget',
+            deleteCommand: '_jupyterlab_variableinspector_deletevariable',
+        },
+        python: {
+            initScript: Languages.py_script,
+            queryCommand: '_jupyterlab_variableinspector_dict_list()',
+            matrixQueryCommand: '_jupyterlab_variableinspector_getmatrixcontent',
+            widgetQueryCommand: '_jupyterlab_variableinspector_displaywidget',
+            deleteCommand: '_jupyterlab_variableinspector_deletevariable',
+        },
+        R: {
+            initScript: Languages.r_script,
+            queryCommand: '.ls.objects()',
+            matrixQueryCommand: '.ls.objects',
+            widgetQueryCommand: 'TODO',
+            deleteCommand: '.deleteVariable',
+        },
+        scala: {
+            initScript: '_root_.almond.api.JupyterAPIHolder.value.VariableInspector.init()',
+            queryCommand: '_root_.almond.api.JupyterAPIHolder.value.VariableInspector.dictList()',
+            matrixQueryCommand: '',
+            widgetQueryCommand: '',
+            deleteCommand: '', // TODO
+        },
+    };
+    static getScript(lang) {
+        return new Promise((resolve, reject) => {
+            if (lang in Languages.scripts) {
+                resolve(Languages.scripts[lang]);
+            }
+            else {
+                reject('Language ' + lang + ' not supported yet!');
+            }
+        });
+    }
+}
+export { Languages };
+//# sourceMappingURL=inspectorscripts.js.map

package/lib/components/kernel/variables/inspectorscripts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectorscripts.js","sourceRoot":"","sources":["../../../../src/components/kernel/variables/inspectorscripts.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAYH,MAAsB,SAAS;IAC7B;;OAEG;IAEH,MAAM,CAAC,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2NpB,CAAC;IAEA,MAAM,CAAC,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqEf,CAAC;IAEJ,MAAM,CAAC,OAAO,GAAiD;QAC7D,OAAO,EAAE;YACP,UAAU,EAAE,SAAS,CAAC,SAAS;YAC/B,YAAY,EAAE,2CAA2C;YACzD,kBAAkB,EAAE,gDAAgD;YACpE,kBAAkB,EAAE,6CAA6C;YACjE,aAAa,EAAE,8CAA8C;SAC9D;QACD,OAAO,EAAE;YACP,UAAU,EAAE,SAAS,CAAC,SAAS;YAC/B,YAAY,EAAE,2CAA2C;YACzD,kBAAkB,EAAE,gDAAgD;YACpE,kBAAkB,EAAE,6CAA6C;YACjE,aAAa,EAAE,8CAA8C;SAC9D;QACD,MAAM,EAAE;YACN,UAAU,EAAE,SAAS,CAAC,SAAS;YAC/B,YAAY,EAAE,2CAA2C;YACzD,kBAAkB,EAAE,gDAAgD;YACpE,kBAAkB,EAAE,6CAA6C;YACjE,aAAa,EAAE,8CAA8C;SAC9D;QACD,CAAC,EAAE;YACD,UAAU,EAAE,SAAS,CAAC,QAAQ;YAC9B,YAAY,EAAE,eAAe;YAC7B,kBAAkB,EAAE,aAAa;YACjC,kBAAkB,EAAE,MAAM;YAC1B,aAAa,EAAE,iBAAiB;SACjC;QACD,KAAK,EAAE;YACL,UAAU,EACR,mEAAmE;YACrE,YAAY,EACV,uEAAuE;YACzE,kBAAkB,EAAE,EAAE;YACtB,kBAAkB,EAAE,EAAE;YACtB,aAAa,EAAE,EAAE,EAAE,OAAO;SAC3B;KACF,CAAC;IAEF,MAAM,CAAC,SAAS,CAAC,IAAY;QAC3B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,IAAI,IAAI,SAAS,CAAC,OAAO,EAAE;gBAC7B,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;aAClC;iBAAM;gBACL,MAAM,CAAC,WAAW,GAAG,IAAI,GAAG,qBAAqB,CAAC,CAAC;aACpD;QACH,CAAC,CAAC,CAAC;IACL,CAAC;;SAzVmB,SAAS"}

package/lib/components/kernel/variables/kernelconnector.d.ts

@@ -0,0 +1,37 @@
+import { KernelMessage } from '@jupyterlab/services';
+import { IKernelConnection, IShellFuture } from '@jupyterlab/services/lib/kernel/kernel';
+import { IExecuteReplyMsg, IExecuteRequestMsg } from '@jupyterlab/services/lib/kernel/messages';
+import { ISignal } from '@lumino/signaling';
+import Kernel from './../../../jupyter/kernel/Kernel';
+/**
+ * Connector class that handles execute request to a kernel
+ */
+export declare class KernelConnector {
+    private _kernel;
+    private _kernelRestarted;
+    constructor(options: KernelConnector.IOptions);
+    get kernelRestarted(): ISignal<KernelConnector, Promise<void>>;
+    get kernelLanguage(): Promise<string>;
+    get kernelName(): string;
+    /**
+     *  A Promise that is fulfilled when the session associated w/ the connector is ready.
+     */
+    get ready(): Promise<void>;
+    /**
+     *  A signal emitted for iopub messages of the kernel associated with the kernel.
+     */
+    get iopubMessage(): ISignal<IKernelConnection, KernelMessage.IMessage>;
+    /**
+     * Executes the given request on the kernel associated with the connector.
+     * @param content: IExecuteRequestMsg to forward to the kernel.
+     * @param ioCallback: Callable to forward IOPub messages of the kernel to.
+     * @returns Promise<KernelMessage.IExecuteReplyMsg>
+     */
+    fetch(content: KernelMessage.IExecuteRequestMsg['content'], ioCallback: (msg: KernelMessage.IIOPubMessage) => any): Promise<KernelMessage.IExecuteReplyMsg>;
+    execute(content: KernelMessage.IExecuteRequestMsg['content']): IShellFuture<IExecuteRequestMsg, IExecuteReplyMsg>;
+}
+export declare namespace KernelConnector {
+    interface IOptions {
+        kernel: Kernel;
+    }
+}

package/lib/components/kernel/variables/kernelconnector.js

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+import { Signal } from '@lumino/signaling';
+/**
+ * Connector class that handles execute request to a kernel
+ */
+export class KernelConnector {
+    _kernel;
+    _kernelRestarted = new Signal(this);
+    constructor(options) {
+        this._kernel = options.kernel;
+        this._kernel.connection?.statusChanged.connect((_, newStatus) => {
+            switch (newStatus) {
+                case 'restarting':
+                case 'autorestarting':
+                    this._kernelRestarted.emit(this._kernel.ready);
+                    break;
+                default:
+                    break;
+            }
+        });
+    }
+    get kernelRestarted() {
+        return this._kernelRestarted;
+    }
+    get kernelLanguage() {
+        if (!this._kernel) {
+            return Promise.resolve('');
+        }
+        return this._kernel.connection.info.then(infoReply => {
+            return infoReply.language_info.name;
+        });
+    }
+    get kernelName() {
+        return this._kernel.connection.name;
+    }
+    /**
+     *  A Promise that is fulfilled when the session associated w/ the connector is ready.
+     */
+    get ready() {
+        return this._kernel.ready;
+    }
+    /**
+     *  A signal emitted for iopub messages of the kernel associated with the kernel.
+     */
+    get iopubMessage() {
+        return this._kernel.connection.iopubMessage;
+    }
+    /**
+     * Executes the given request on the kernel associated with the connector.
+     * @param content: IExecuteRequestMsg to forward to the kernel.
+     * @param ioCallback: Callable to forward IOPub messages of the kernel to.
+     * @returns Promise<KernelMessage.IExecuteReplyMsg>
+     */
+    fetch(content, ioCallback) {
+        const kernel = this._kernel.connection;
+        if (!kernel) {
+            return Promise.reject(new Error('Require kernel to perform variable inspection!'));
+        }
+        const future = kernel.requestExecute(content);
+        future.onIOPub = (msg) => {
+            ioCallback(msg);
+        };
+        return future.done;
+    }
+    execute(content) {
+        if (!this._kernel.connection) {
+            throw new Error('No session available.');
+        }
+        return this._kernel.connection.requestExecute(content);
+    }
+}
+//# sourceMappingURL=kernelconnector.js.map

package/lib/components/kernel/variables/kernelconnector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernelconnector.js","sourceRoot":"","sources":["../../../../src/components/kernel/variables/kernelconnector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAWH,OAAO,EAAW,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAGpD;;GAEG;AACH,MAAM,OAAO,eAAe;IAClB,OAAO,CAAS;IAChB,gBAAgB,GAAG,IAAI,MAAM,CAAsB,IAAI,CAAC,CAAC;IAEjE,YAAY,OAAiC;QAC3C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;QAC9B,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,aAAa,CAAC,OAAO,CAC5C,CAAC,CAAC,EAAE,SAA+B,EAAE,EAAE;YACrC,QAAQ,SAAS,EAAE;gBACjB,KAAK,YAAY,CAAC;gBAClB,KAAK,gBAAgB;oBACnB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;oBAC/C,MAAM;gBACR;oBACE,MAAM;aACT;QACH,CAAC,CACF,CAAC;IACJ,CAAC;IAED,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED,IAAI,cAAc;QAChB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;YACjB,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;SAC5B;QACD,OAAO,IAAI,CAAC,OAAO,CAAC,UAAW,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE;YACpD,OAAO,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC;QACtC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,OAAO,CAAC,UAAW,CAAC,IAAI,CAAC;IACvC,CAAC;IAED;;OAEG;IACH,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,OAAO,CAAC,UAAW,CAAC,YAAY,CAAC;IAC/C,CAAC;IAED;;;;;OAKG;IACH,KAAK,CACH,OAAoD,EACpD,UAAqD;QAErD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;QACvC,IAAI,CAAC,MAAM,EAAE;YACX,OAAO,OAAO,CAAC,MAAM,CACnB,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAC5D,CAAC;SACH;QACD,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC9C,MAAM,CAAC,OAAO,GAAG,CAAC,GAAgC,EAAQ,EAAE;YAC1D,UAAU,CAAC,GAAG,CAAC,CAAC;QAClB,CAAC,CAAC;QACF,OAAO,MAAM,CAAC,IAA+C,CAAC;IAChE,CAAC;IAED,OAAO,CACL,OAAoD;QAEpD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE;YAC5B,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;SAC1C;QACD,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IACzD,CAAC;CACF"}

package/lib/components/kernel/variables/manager.d.ts

@@ -0,0 +1,26 @@
+import { VariableInspectionHandler } from './handler';
+import { VariableInspectorPanel } from './widget';
+import { IVariableInspector, IVariableInspectorManager } from './tokens';
+/**
+ * A class that manages variable inspector widget instances and offers persistent
+ * `IVariableInspector` instance that other plugins can communicate with.
+ */
+export declare class VariableInspectorManager implements IVariableInspectorManager {
+    private _source;
+    private _panel?;
+    private _handlers;
+    hasHandler(id: string): boolean;
+    getHandler(id: string): VariableInspectionHandler;
+    addHandler(handler: VariableInspectionHandler): void;
+    /**
+     * The current inspector panel.
+     */
+    get panel(): VariableInspectorPanel | undefined;
+    set panel(panel: VariableInspectorPanel | undefined);
+    /**
+     * The source of events the inspector panel listens for.
+     */
+    get source(): IVariableInspector.IInspectable | null;
+    set source(source: IVariableInspector.IInspectable | null);
+    private _onSourceDisposed;
+}

package/lib/components/kernel/variables/manager.js

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+/**
+ * A class that manages variable inspector widget instances and offers persistent
+ * `IVariableInspector` instance that other plugins can communicate with.
+ */
+export class VariableInspectorManager {
+    _source = null;
+    _panel;
+    _handlers = {};
+    hasHandler(id) {
+        if (this._handlers[id]) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    getHandler(id) {
+        return this._handlers[id];
+    }
+    addHandler(handler) {
+        this._handlers[handler.id] = handler;
+    }
+    /**
+     * The current inspector panel.
+     */
+    get panel() {
+        return this._panel;
+    }
+    set panel(panel) {
+        if (this.panel === panel) {
+            return;
+        }
+        this._panel = panel;
+        if (panel && !panel.source) {
+            panel.source = this._source;
+        }
+    }
+    /**
+     * The source of events the inspector panel listens for.
+     */
+    get source() {
+        return this._source;
+    }
+    set source(source) {
+        if (this._source === source) {
+            return;
+        }
+        // remove subscriptions
+        if (this._source) {
+            this._source.disposed.disconnect(this._onSourceDisposed, this);
+        }
+        this._source = source;
+        if (this._panel && !this._panel.isDisposed) {
+            this._panel.source = this._source;
+        }
+        // Subscribe to new source
+        if (this._source) {
+            this._source.disposed.connect(this._onSourceDisposed, this);
+        }
+    }
+    _onSourceDisposed() {
+        this._source = null;
+    }
+}
+//# sourceMappingURL=manager.js.map

package/lib/components/kernel/variables/manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.js","sourceRoot":"","sources":["../../../../src/components/kernel/variables/manager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH;;;GAGG;AACH,MAAM,OAAO,wBAAwB;IAC3B,OAAO,GAA2C,IAAI,CAAC;IACvD,MAAM,CAA0B;IAChC,SAAS,GAAgD,EAAE,CAAC;IAEpE,UAAU,CAAC,EAAU;QACnB,IAAI,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE;YACtB,OAAO,IAAI,CAAC;SACb;aAAM;YACL,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAED,UAAU,CAAC,EAAU;QACnB,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;IAED,UAAU,CAAC,OAAkC;QAC3C,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IACvC,CAAC;IAED;;OAEG;IACH,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,IAAI,KAAK,CAAC,KAAyC;QACjD,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,EAAE;YACxB,OAAO;SACR;QACD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QAEpB,IAAI,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;YAC1B,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC;SAC7B;IACH,CAAC;IAED;;OAEG;IACH,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,IAAI,MAAM,CAAC,MAA8C;QACvD,IAAI,IAAI,CAAC,OAAO,KAAK,MAAM,EAAE;YAC3B,OAAO;SACR;QAED,uBAAuB;QACvB,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;SAChE;QAED,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QAEtB,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE;YAC1C,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC;SACnC;QACD,0BAA0B;QAC1B,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;SAC7D;IACH,CAAC;IAEO,iBAAiB;QACvB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;CACF"}

package/lib/components/kernel/variables/tokens.d.ts

@@ -0,0 +1,48 @@
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { Kernel, KernelMessage } from '@jupyterlab/services';
+import { DataModel } from '@lumino/datagrid';
+import { IObservableDisposable } from '@lumino/disposable';
+import { ISignal } from '@lumino/signaling';
+import type { VariableInspectionHandler } from './handler';
+export interface IVariableInspectorManager {
+    source: IVariableInspector.IInspectable | null;
+    hasHandler(id: string): boolean;
+    getHandler(id: string): VariableInspectionHandler;
+    addHandler(handler: VariableInspectionHandler): void;
+}
+/**
+ * An interface for an inspector.
+ */
+export interface IVariableInspector {
+    source: IVariableInspector.IInspectable | null;
+}
+/**
+ * A namespace for inspector interfaces.
+ */
+export declare namespace IVariableInspector {
+    interface IInspectable extends IObservableDisposable {
+        inspected: ISignal<IInspectable, IVariableInspectorUpdate>;
+        rendermime: IRenderMimeRegistry | null;
+        performInspection(): void;
+        performMatrixInspection(varName: string, maxRows?: number): Promise<DataModel>;
+        performWidgetInspection(varName: string): Kernel.IShellFuture<KernelMessage.IExecuteRequestMsg, KernelMessage.IExecuteReplyMsg>;
+        performDelete(varName: string): void;
+    }
+    interface IVariableInspectorUpdate {
+        title: IVariableTitle;
+        payload: Array<IVariable>;
+    }
+    interface IVariable {
+        varName: string;
+        varSize: string;
+        varShape: string;
+        varContent: string;
+        varType: string;
+        isMatrix: boolean;
+        isWidget: boolean;
+    }
+    interface IVariableTitle {
+        kernelName?: string;
+        contextName?: string;
+    }
+}

package/lib/components/kernel/variables/tokens.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+export {};
+//# sourceMappingURL=tokens.js.map

package/lib/components/kernel/variables/tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.js","sourceRoot":"","sources":["../../../../src/components/kernel/variables/tokens.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}