@datalayer/core 0.0.1 → 0.0.3

package/lib/api/DatalayerApi.js

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { URLExt } from '@jupyterlab/coreutils';
+import { sleep } from '../utils';
+/**
+ * A wrapped error for a fetch response.
+ */
+export class RunResponseError extends Error {
+    /**
+     * Create a RunResponseError from a response,
+     * handling the traceback and message as appropriate.
+     *
+     * @param response The response object.
+     *
+     * @returns A promise that resolves with a `RunResponseError` object.
+     */
+    static async create(response) {
+        try {
+            const data = await response.json();
+            const { message, errors, warnings, traceback, exception } = data;
+            if (traceback) {
+                console.error(traceback);
+            }
+            const responseError = new RunResponseError(response, message ?? RunResponseError._defaultMessage(response), warnings, errors, exception, traceback ?? '');
+            return responseError;
+        }
+        catch (e) {
+            console.debug(e);
+            return new RunResponseError(response);
+        }
+    }
+    /**
+     * Create a new response error.
+     */
+    constructor(response, message = RunResponseError._defaultMessage(response), warnings = undefined, errors = undefined, exceptionMessage = undefined, traceback = '') {
+        super(message);
+        this.name = 'RunResponseError';
+        this.warnings = warnings ?? [];
+        this.errors = errors ?? [];
+        this.response = response;
+        this.exceptionMessage = exceptionMessage;
+        this.traceback = traceback;
+    }
+    /**
+     * Warnings listed in the response.
+     */
+    warnings;
+    /**
+     * Errors listed in the response.
+     */
+    errors;
+    /**
+     * The response associated with the error.
+     */
+    response;
+    /**
+     * The exception associated with the error.
+     */
+    exceptionMessage;
+    /**
+     * The traceback associated with the error.
+     */
+    traceback;
+    static _defaultMessage(response) {
+        return `Invalid response: ${response.status} ${response.statusText}`;
+    }
+}
+/**
+ * A wrapped error for a network error.
+ */
+export class NetworkError extends TypeError {
+    /**
+     * Create a new network error.
+     */
+    constructor(original) {
+        super(original.message);
+        this.name = 'NetworkError';
+        this.stack = original.stack;
+    }
+}
+export async function requestDatalayerAPI({ url, method, body, token, signal, headers = {} }) {
+    const headers_ = new Headers(headers);
+    if (!headers_.has('Accept')) {
+        headers_.set('Accept', 'application/json');
+    }
+    if (!headers_.has('Content-Type')) {
+        headers_.set('Content-Type', 'application/json');
+    }
+    if (token) {
+        headers_.set('Authorization', `Bearer ${token}`);
+    }
+    //  headers_.set('Origin', currentUri());
+    let response;
+    try {
+        response = await fetch(url, {
+            method: method ?? 'GET',
+            headers: headers_,
+            body: body ? JSON.stringify(body) : undefined,
+            // credentials: token ? 'include' : 'omit',
+            credentials: 'include',
+            mode: 'cors',
+            cache: 'no-store',
+            signal
+        });
+    }
+    catch (error) {
+        throw new NetworkError(error);
+    }
+    if (response.ok) {
+        response = await wait_for_redirection(response, url, headers_);
+        const content = await response.text();
+        return (content ? JSON.parse(content) : null);
+    }
+    else {
+        throw await RunResponseError.create(response);
+    }
+}
+async function wait_for_redirection(response, url, headers_) {
+    let redirect = response.headers.get('Location');
+    if (redirect) {
+        const parsedURL = URLExt.parse(url);
+        const baseUrl = parsedURL.protocol + '//' + parsedURL.hostname;
+        if (!redirect.startsWith(baseUrl)) {
+            redirect = URLExt.join(baseUrl, redirect);
+        }
+    }
+    let sleepTimeout = 1000;
+    while (response.status === 202 && redirect) {
+        await sleep(sleepTimeout);
+        sleepTimeout *= 2;
+        response = await fetch(redirect, {
+            method: 'GET',
+            headers: headers_,
+            credentials: 'include',
+            mode: 'cors',
+            cache: 'no-store'
+        });
+        if (!response.ok) {
+            throw await RunResponseError.create(response);
+        }
+    }
+    return response;
+}

package/lib/api/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./jupyter";
+export * from "./runtimes";
+export * from "./DatalayerApi";

package/lib/api/index.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from "./jupyter";
+export * from "./runtimes";
+export * from "./DatalayerApi";

package/lib/api/jupyter/exec/Python.d.ts

@@ -0,0 +1,5 @@
+export declare function listVariables(): string;
+export declare function saveVariables(variables: string[]): string;
+export declare function loadVariables(variables: string): string;
+export declare function changeCurrentWorkingDirectory(path: string): string;
+export declare function getOutputCandidates(code: string): string[];

package/lib/api/jupyter/exec/Python.js

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export function listVariables() {
+    return `
+def _list_variables():
+    import json
+    from types import BuiltinFunctionType, BuiltinMethodType, FunctionType, MethodType, MethodWrapperType, ModuleType, TracebackType
+
+    _FORBIDDEN_TYPES = [type, BuiltinFunctionType, BuiltinMethodType, FunctionType, MethodType, MethodWrapperType, ModuleType, TracebackType]
+    try:
+        from IPython.core.autocall import ExitAutocall
+        _FORBIDDEN_TYPES.append(ExitAutocall)
+    except ImportError:
+        pass
+    _exclude = tuple(_FORBIDDEN_TYPES)
+
+    _all = frozenset(globals())
+    _vars = {}
+    for _n in _all:
+        _v = globals()[_n]
+        
+        if not (
+            _n.startswith('_') or
+            isinstance(_v, _exclude) or
+            # Special IPython variables
+            (_n == 'In' and isinstance(_v, list)) or
+            (_n == 'Out' and isinstance(_v, dict))
+        ):
+            _vars[_n] = type(_v).__qualname__
+
+    return json.dumps(_vars)
+
+_list_variables()`;
+}
+export function saveVariables(variables) {
+    return `
+def _pickle_variables():
+    from base64 import encodebytes
+    import json
+    import pickle
+    _names = {${variables.map(v => `"${v}"`).join(',')}}
+    _data = {}
+    for _n in _names:
+        try:
+            _v = globals()[_n]
+            dump = pickle.dumps(_v)
+            _data[_n] = encodebytes(dump).decode("ascii")
+        except:
+            ...
+
+    return json.dumps(_data)
+
+_pickle_variables()
+`;
+}
+export function loadVariables(variables) {
+    return `
+def _load_variables():
+    from base64 import decodebytes
+    import json
+    import pickle
+    _data = json.loads(${variables})
+    _loaded = []
+    for _n, _v in _data.items():
+        try:
+            dump = decodebytes(_v.encode("ascii"))
+            globals()[_n] = pickle.loads(dump)
+            _loaded.append(_n)
+        except:
+            ...
+    return json.dumps(_loaded)
+
+_load_variables()
+`;
+}
+export function changeCurrentWorkingDirectory(path) {
+    const formattedPath = path
+        .split('/')
+        .map(seg => `"${seg}"`)
+        .join(' / ');
+    return `
+def _change_current_directory():
+    import os
+    from pathlib import Path
+    _local_content_mount_point = Path(Path.home() / ${formattedPath})
+    _local_content_mount_point.mkdir(parents=True, exist_ok=True)
+    os.chdir(_local_content_mount_point)
+
+    assert Path.cwd() == _local_content_mount_point
+
+_change_current_directory()
+`;
+}
+export function getOutputCandidates(code) {
+    return Array.from(code.matchAll(/^((?<output>[A-z][\w]*)\s*=[^=]|\((?<walrus>[A-z][\w]*)\s*:=[^=)]+\))/gm))
+        .map(match => match.groups?.output ?? match.groups?.walrus ?? '')
+        .filter(n => !!n);
+}

package/lib/api/jupyter/exec/Snippets.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Runtime snippets.
+ */
+export interface IRuntimeSnippets {
+    /**
+     * Code snippet to change the current working directory.
+     *
+     * The code snippet has no returned value.
+     *
+     * The path is relative to the home directory and use
+     * the separator `/`.
+     *
+     * @param path New current directory
+     * @returns The code snippet
+     */
+    changeCurrentWorkingDirectory(path: string): string;
+    /**
+     * Code snippet to list the transferable kernel variables.
+     *
+     * The code snippet must return a serialized-JSON
+     * dictionary (<variable name>, <variable type>)
+     *
+     * @returns The code snippet
+     */
+    listVariables(): string;
+    /**
+     * Code snippet to load kernel variables.
+     *
+     * The code snippet must return a serialized-JSON list
+     * with successfully loaded variables.
+     *
+     * The format used to store the variable value is up to the kernel.
+     * It should JSON-serializable and will be passed from {@link saveVariables}.
+     *
+     * @param variables Serialized-JSON dictionary (<variable name>, <variable value blob>)
+     * @returns The code snippet
+     */
+    loadVariables(variables: string): string;
+    /**
+     * Code snippet to save kernel variables.
+     *
+     * The code snippet must return a serialized-JSON dictionary
+     * (<variable name>, <variable value blob>).
+     *
+     * The format used to store the variable value is up to the kernel.
+     * It should JSON-serializable and will be passed to {@link loadVariables}
+     * without modification.
+     *
+     * @param variables Variable names.
+     * @returns The code snippet
+     */
+    saveVariables(variables: string[]): string;
+    /**
+     * Extract output variables candidates by parsing the cell content.
+     *
+     * @param code Cell code source
+     * @returns The output variable candidates
+     */
+    getOutputCandidates(code: string): string[];
+}
+/**
+ * Facade to interact with kernels by requesting code execution.
+ */
+export declare class RuntimeSnippetsFacade {
+    private static $language;
+    /**
+     * Register a facade for a given language
+     *
+     * @param language Kernel language
+     * @param API Kernel API
+     */
+    static register(language: string, API: IRuntimeSnippets): void;
+    /**
+     * Whether there is an API for the given kernel language
+     *
+     * @param language Kernel language
+     */
+    static supports(language: string): boolean;
+    private _language;
+    /**
+     * Create a kernel snippet generator for a given kernel
+     * language.
+     *
+     * It will raise if the language is not available.
+     *
+     * @param language Kernel language
+     */
+    constructor(language: string);
+    /**
+     * Kernel language
+     */
+    get language(): string;
+    /**
+     * Code snippet to change the current working directory.
+     *
+     * The code snippet has no returned value.
+     *
+     * @param path New current directory
+     * @returns The code snippet
+     */
+    changeCurrentWorkingDirectory(path: string): string;
+    /**
+     * Code snippet to list the transferable kernel variables.
+     *
+     * The code snippet must return a serialized-JSON
+     * dictionary (<variable name>, <variable type>)
+     *
+     * @returns The code snippet
+     */
+    listVariables(): string;
+    /**
+     * Code snippet to load kernel variables.
+     *
+     * The code snippet must return a serialized-JSON list
+     * with successfully loaded variables.
+     *
+     * The format used to store the variable value is up to the kernel.
+     * It should JSON-serializable and will be passed from {@link saveVariables}.
+     *
+     * @param variables Serialized-JSON dictionary (<variable name>, <variable value blob>)
+     * @returns The code snippet
+     */
+    loadVariables(variables: string): string;
+    /**
+     * Code snippet to save kernel variables.
+     *
+     * The code snippet must return a serialized-JSON dictionary
+     * (<variable name>, <variable value blob>).
+     *
+     * The format used to store the variable value is up to the kernel.
+     * It should JSON-serializable and will be passed to {@link loadVariables}
+     * without modification.
+     *
+     * @param variables Variable names.
+     * @returns The code snippet
+     */
+    saveVariables(variables: string[]): string;
+    /**
+     * Extract output variables candidates by parsing the cell content.
+     *
+     * @param code Cell code source
+     * @returns The output variable candidates
+     */
+    getOutputCandidates(code: string): string[];
+}

package/lib/api/jupyter/exec/Snippets.js

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import * as Python from './Python';
+/**
+ * Facade to interact with kernels by requesting code execution.
+ */
+export class RuntimeSnippetsFacade {
+    static $language = new Map();
+    /**
+     * Register a facade for a given language
+     *
+     * @param language Kernel language
+     * @param API Kernel API
+     */
+    static register(language, API) {
+        this.$language.set(language, API);
+    }
+    /**
+     * Whether there is an API for the given kernel language
+     *
+     * @param language Kernel language
+     */
+    static supports(language) {
+        return this.$language.has(language);
+    }
+    _language;
+    /**
+     * Create a kernel snippet generator for a given kernel
+     * language.
+     *
+     * It will raise if the language is not available.
+     *
+     * @param language Kernel language
+     */
+    constructor(language) {
+        if (!RuntimeSnippetsFacade.$language.has(language)) {
+            throw new Error(`${language} is not supported.`);
+        }
+        this._language = language;
+    }
+    /**
+     * Kernel language
+     */
+    get language() {
+        return this._language;
+    }
+    /**
+     * Code snippet to change the current working directory.
+     *
+     * The code snippet has no returned value.
+     *
+     * @param path New current directory
+     * @returns The code snippet
+     */
+    changeCurrentWorkingDirectory(path) {
+        return RuntimeSnippetsFacade.$language
+            .get(this.language)
+            .changeCurrentWorkingDirectory(path);
+    }
+    /**
+     * Code snippet to list the transferable kernel variables.
+     *
+     * The code snippet must return a serialized-JSON
+     * dictionary (<variable name>, <variable type>)
+     *
+     * @returns The code snippet
+     */
+    listVariables() {
+        return RuntimeSnippetsFacade.$language.get(this.language).listVariables();
+    }
+    /**
+     * Code snippet to load kernel variables.
+     *
+     * The code snippet must return a serialized-JSON list
+     * with successfully loaded variables.
+     *
+     * The format used to store the variable value is up to the kernel.
+     * It should JSON-serializable and will be passed from {@link saveVariables}.
+     *
+     * @param variables Serialized-JSON dictionary (<variable name>, <variable value blob>)
+     * @returns The code snippet
+     */
+    loadVariables(variables) {
+        return RuntimeSnippetsFacade.$language
+            .get(this.language)
+            .loadVariables(variables);
+    }
+    /**
+     * Code snippet to save kernel variables.
+     *
+     * The code snippet must return a serialized-JSON dictionary
+     * (<variable name>, <variable value blob>).
+     *
+     * The format used to store the variable value is up to the kernel.
+     * It should JSON-serializable and will be passed to {@link loadVariables}
+     * without modification.
+     *
+     * @param variables Variable names.
+     * @returns The code snippet
+     */
+    saveVariables(variables) {
+        return RuntimeSnippetsFacade.$language
+            .get(this.language)
+            .saveVariables(variables);
+    }
+    /**
+     * Extract output variables candidates by parsing the cell content.
+     *
+     * @param code Cell code source
+     * @returns The output variable candidates
+     */
+    getOutputCandidates(code) {
+        return RuntimeSnippetsFacade.$language
+            .get(this.language)
+            .getOutputCandidates(code);
+    }
+}
+RuntimeSnippetsFacade.register('python', Python);

package/lib/api/jupyter/exec/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Python';
+export * from './Snippets';

package/lib/api/jupyter/exec/index.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './Python';
+export * from './Snippets';

package/lib/api/jupyter/index.d.ts

@@ -0,0 +1,2 @@
+export * from './exec';
+export * from './kernelsHandler';

package/lib/api/jupyter/index.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './exec';
+export * from './kernelsHandler';

package/lib/api/jupyter/kernelsHandler.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Call the jupyter_kernels extension
+ *
+ * @param endPoint API REST end point for the extension
+ * @param init Initial values for the request
+ * @returns The response body interpreted as JSON
+ */
+export declare function requestJupyterKernelsExtension<T>(endPoint?: string, init?: RequestInit): Promise<T>;

package/lib/api/jupyter/kernelsHandler.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { URLExt } from '@jupyterlab/coreutils';
+import { ServerConnection } from '@jupyterlab/services';
+/**
+ * Call the jupyter_kernels extension
+ *
+ * @param endPoint API REST end point for the extension
+ * @param init Initial values for the request
+ * @returns The response body interpreted as JSON
+ */
+export async function requestJupyterKernelsExtension(endPoint = '', init = {}) {
+    // Make request to Jupyter API
+    const settings = ServerConnection.makeSettings();
+    const requestUrl = URLExt.join(settings.baseUrl, 'jupyter_kernels', // API Namespace
+    endPoint);
+    let response;
+    try {
+        response = await ServerConnection.makeRequest(requestUrl, init, settings);
+    }
+    catch (error) {
+        throw new ServerConnection.NetworkError(error);
+    }
+    let data = await response.text();
+    if (data.length > 0) {
+        try {
+            data = JSON.parse(data);
+        }
+        catch (error) {
+            console.log('Not a JSON response body.', response);
+        }
+    }
+    if (!response.ok) {
+        throw new ServerConnection.ResponseError(response, data.message || data);
+    }
+    return data;
+}