@datalayer/agent-runtimes 1.0.9 → 1.0.17

package/lib/examples2/main.js

@@ -0,0 +1,330 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/// <reference types="vite/client" />
+import { useEffect, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { loadJupyterConfig, JupyterReactTheme, createServerSettings, setJupyterServerUrl, setJupyterServerToken, getJupyterServerUrl, getJupyterServerToken, } from '@datalayer/jupyter-react';
+import { ServiceManager } from '@jupyterlab/services';
+import { coreStore } from '../state';
+import { iamStore } from '../state';
+import { EXAMPLES } from './example-selector';
+import { createDatalayerServiceManager } from '../services/DatalayerServiceManager';
+import { BOOTSTRAP_USER_ONBOARDING } from '@datalayer/core/lib/models/UserOnboarding';
+import nbformatExample from './notebooks/NotebookExample1.ipynb.json';
+const DEFAULT_RUNTIMES_URL = 'https://r1.datalayer.run';
+const resolveRuntimesUrl = (configured) => {
+    const envRuntimeUrl = import.meta.env.VITE_DATALAYER_RUNTIMES_URL;
+    const envBaseUrl = import.meta.env.VITE_DATALAYER_URL;
+    const candidate = configured || envRuntimeUrl || envBaseUrl;
+    if (!candidate) {
+        return DEFAULT_RUNTIMES_URL;
+    }
+    if (candidate.includes('prod1.datalayer.run')) {
+        return DEFAULT_RUNTIMES_URL;
+    }
+    return candidate.replace(/\/$/, '');
+};
+// Load configurations from DOM
+const loadConfigurations = () => {
+    // Load Datalayer configuration
+    const datalayerConfigElement = document.getElementById('datalayer-config-data');
+    if (datalayerConfigElement?.textContent) {
+        try {
+            const datalayerConfig = JSON.parse(datalayerConfigElement.textContent);
+            // If token is empty or still has placeholder, use environment variable from .env
+            if (!datalayerConfig.token ||
+                datalayerConfig.token.startsWith('%VITE_')) {
+                const envToken = import.meta.env.VITE_DATALAYER_API_KEY;
+                if (envToken) {
+                    datalayerConfig.token = envToken;
+                }
+            }
+            if (datalayerConfig.datalayerUrl) {
+                datalayerConfig.runtimesUrl = resolveRuntimesUrl(datalayerConfig.runtimesUrl);
+                coreStore.getState().setConfiguration(datalayerConfig);
+                // Also set the token in the IAM store for API authentication
+                if (datalayerConfig.token) {
+                    // Use the setLogin method to set the token in IAM store
+                    // For now, we'll just set a minimal user object since we don't have full user data
+                    iamStore.getState().setLogin({
+                        id: 'example-id',
+                        handle: 'example-user',
+                        email: 'example@datalayer.com',
+                        firstName: 'Example',
+                        lastName: 'User',
+                        initials: 'EU',
+                        displayName: 'Example User',
+                        avatarUrl: '',
+                        roles: [],
+                        setRoles: () => { },
+                        iamProviders: [],
+                        settings: {},
+                        unsubscribedFromOutbounds: false,
+                        onboarding: { ...BOOTSTRAP_USER_ONBOARDING },
+                        events: [],
+                    }, datalayerConfig.token);
+                }
+            }
+        }
+        catch (e) {
+            console.error('Failed to parse Datalayer config:', e);
+        }
+    }
+    // Load Jupyter configuration
+    loadJupyterConfig();
+    // Also set Jupyter server URL and token if available in jupyter-config-data
+    const jupyterConfigElement = document.getElementById('jupyter-config-data');
+    if (jupyterConfigElement?.textContent) {
+        try {
+            const jupyterConfig = JSON.parse(jupyterConfigElement.textContent);
+            if (jupyterConfig.baseUrl) {
+                setJupyterServerUrl(jupyterConfig.baseUrl);
+            }
+            if (jupyterConfig.token) {
+                setJupyterServerToken(jupyterConfig.token);
+            }
+        }
+        catch (e) {
+            console.error('Failed to parse Jupyter config:', e);
+        }
+    }
+};
+const getExampleNames = () => Object.keys(EXAMPLES);
+// Check if we're on the notebook-only route
+const isNotebookOnlyRoute = () => {
+    const path = window.location.pathname;
+    console.warn('[DEBUG] Current pathname:', path);
+    const isNotebookRoute = path === '/datalayer/notebook';
+    console.warn('[DEBUG] Is notebook-only route:', isNotebookRoute);
+    return isNotebookRoute;
+};
+// Get the default example name from localStorage
+const getDefaultExampleName = () => {
+    const stored = localStorage.getItem('selectedExample');
+    if (stored && EXAMPLES[stored]) {
+        return stored;
+    }
+    return 'DatalayerNotebookExample';
+};
+// Notebook-only component for iframe display - renders ONLY the notebook without any UI chrome
+const NotebookOnlyApp = () => {
+    const [serviceManager, setServiceManager] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [nbformat] = useState(nbformatExample);
+    const [NotebookComponent, setNotebookComponent] = 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    useState(null);
+    const [collaborationProvider, setCollaborationProvider] = useState(null);
+    useEffect(() => {
+        loadConfigurations();
+        const initializeApp = async () => {
+            try {
+                const { configuration } = coreStore.getState();
+                // Always try to create collaboration provider if we have token and datalayerUrl
+                if (configuration?.token && configuration?.datalayerUrl) {
+                    try {
+                        const { DatalayerCollaborationProvider } = await import('../collaboration/DatalayerCollaborationProvider');
+                        const provider = new DatalayerCollaborationProvider({
+                            datalayerUrl: configuration.datalayerUrl,
+                            token: configuration.token,
+                        });
+                        console.warn('[NotebookOnlyApp] Created collaboration provider:', provider);
+                        setCollaborationProvider(provider);
+                    }
+                    catch (error) {
+                        console.error('Failed to create DatalayerCollaborationProvider:', error);
+                    }
+                }
+                // Create service manager
+                if (configuration?.token) {
+                    try {
+                        const manager = await createDatalayerServiceManager(configuration.cpuEnvironment || 'python-3.11', configuration.credits || 100);
+                        await manager.ready;
+                        setServiceManager(manager);
+                    }
+                    catch (error) {
+                        console.error('Failed to create DatalayerServiceManager:', error);
+                        const serverSettings = createServerSettings(getJupyterServerUrl(), getJupyterServerToken());
+                        const manager = new ServiceManager({ serverSettings });
+                        await manager.ready;
+                        setServiceManager(manager);
+                    }
+                }
+                else {
+                    const serverSettings = createServerSettings(getJupyterServerUrl(), getJupyterServerToken());
+                    const manager = new ServiceManager({ serverSettings });
+                    await manager.ready;
+                    setServiceManager(manager);
+                }
+                setLoading(false);
+            }
+            catch (e) {
+                console.error('Failed to initialize app:', e);
+                setError(`Failed to initialize app: ${e}`);
+                setLoading(false);
+            }
+        };
+        initializeApp();
+    }, []);
+    useEffect(() => {
+        // Dynamically import Notebook component
+        import('@datalayer/jupyter-react').then(module => {
+            setNotebookComponent(() => module.Notebook);
+        });
+    }, []);
+    if (loading || !NotebookComponent) {
+        return (_jsxs("div", { style: { padding: '20px', textAlign: 'center' }, children: [_jsx("h2", { children: "Loading Notebook..." }), _jsx("p", { children: "Please wait..." })] }));
+    }
+    if (error) {
+        return (_jsxs("div", { style: { padding: '20px', color: 'red' }, children: [_jsx("h2", { children: "Error Loading Notebook" }), _jsx("pre", { children: error })] }));
+    }
+    if (!serviceManager) {
+        return null;
+    }
+    const NOTEBOOK_ID = '01JZQRQ35GG871QQCZW9TB1A8J';
+    console.warn('[NotebookOnlyApp] Rendering with:', {
+        hasServiceManager: !!serviceManager,
+        hasCollaborationProvider: !!collaborationProvider,
+        notebookId: NOTEBOOK_ID,
+    });
+    return (_jsx(JupyterReactTheme, { children: _jsx("div", { style: { width: '100vw', height: '100vh' }, children: _jsx(NotebookComponent, { id: NOTEBOOK_ID, height: "100vh", nbformat: nbformat, readonly: false, serviceManager: serviceManager, startDefaultKernel: true, collaborationProvider: collaborationProvider }) }) }));
+};
+// Main App component that loads and renders the selected example
+export const ExampleApp = () => {
+    const [ExampleComponent, setExampleComponent] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [serviceManager, setServiceManager] = useState(null);
+    const [selectedExample, setSelectedExample] = useState(getDefaultExampleName());
+    const [isChangingExample, setIsChangingExample] = useState(false);
+    const loadExample = async (exampleName, _manager) => {
+        try {
+            setIsChangingExample(true);
+            setError(null);
+            const exampleLoader = EXAMPLES[exampleName];
+            if (!exampleLoader) {
+                throw new Error(`Example "${exampleName}" not found`);
+            }
+            const module = await exampleLoader();
+            setExampleComponent(() => module.default);
+            setIsChangingExample(false);
+        }
+        catch (e) {
+            console.error('Failed to load example:', e);
+            setError(`Failed to load example: ${e}`);
+            setIsChangingExample(false);
+        }
+    };
+    useEffect(() => {
+        // Load configurations
+        loadConfigurations();
+        // Create service manager and load example - must be sequential
+        const initializeApp = async () => {
+            try {
+                const { configuration } = coreStore.getState();
+                // Try to use DatalayerServiceManager if we have a token
+                if (configuration?.token) {
+                    try {
+                        const manager = await createDatalayerServiceManager(configuration.cpuEnvironment || 'python-3.11', configuration.credits || 100);
+                        await manager.ready;
+                        setServiceManager(manager);
+                        // Load initial example
+                        await loadExample(selectedExample, manager);
+                    }
+                    catch (error) {
+                        console.error('Failed to create DatalayerServiceManager:', error);
+                        // Fall back to regular ServiceManager
+                        const serverSettings = createServerSettings(getJupyterServerUrl(), getJupyterServerToken());
+                        const manager = new ServiceManager({ serverSettings });
+                        await manager.ready;
+                        setServiceManager(manager);
+                        // Load initial example
+                        await loadExample(selectedExample, manager);
+                    }
+                }
+                else {
+                    // Use regular ServiceManager (no Datalayer token)
+                    const serverSettings = createServerSettings(getJupyterServerUrl(), getJupyterServerToken());
+                    const manager = new ServiceManager({ serverSettings });
+                    await manager.ready;
+                    setServiceManager(manager);
+                    // Load initial example
+                    await loadExample(selectedExample, manager);
+                }
+                setLoading(false);
+            }
+            catch (e) {
+                console.error('Failed to initialize app:', e);
+                setError(`Failed to initialize app: ${e}`);
+                setLoading(false);
+            }
+        };
+        initializeApp();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const handleExampleChange = async (newExample) => {
+        if (newExample === selectedExample || !serviceManager)
+            return;
+        setSelectedExample(newExample);
+        localStorage.setItem('selectedExample', newExample);
+        await loadExample(newExample, serviceManager);
+    };
+    if (loading) {
+        return (_jsxs("div", { style: { padding: '20px', textAlign: 'center' }, children: [_jsxs("h2", { children: ["Loading Example: ", selectedExample] }), _jsx("p", { children: "Please wait..." })] }));
+    }
+    if (error && !ExampleComponent) {
+        return (_jsxs("div", { style: { padding: '20px', color: 'red' }, children: [_jsx("h2", { children: "Error Loading Example" }), _jsx("pre", { children: error })] }));
+    }
+    if (!ExampleComponent && !isChangingExample) {
+        return (_jsxs("div", { style: { padding: '20px' }, children: [_jsx("h2", { children: "Example Not Found" }), _jsx("p", { children: "The selected example could not be loaded." })] }));
+    }
+    // Check if the example component expects props
+    // Most examples will need serviceManager
+    const exampleProps = {};
+    if (serviceManager) {
+        exampleProps.serviceManager = serviceManager;
+    }
+    return (_jsx(JupyterReactTheme, { children: _jsxs("div", { style: { width: '100vw', height: '100vh', overflow: 'hidden' }, children: [_jsxs("div", { style: {
+                        position: 'relative',
+                        zIndex: 9999,
+                        padding: '10px 20px',
+                        background: '#f0f0f0',
+                        borderBottom: '1px solid #ccc',
+                        display: 'flex',
+                        alignItems: 'center',
+                        justifyContent: 'space-between',
+                        gap: '15px',
+                        fontSize: '14px',
+                        fontFamily: 'system-ui, -apple-system, sans-serif',
+                    }, children: [_jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: '15px' }, children: [_jsx("label", { style: { fontWeight: 500, color: '#333' }, children: "Select Example:" }), _jsx("select", { value: selectedExample, onChange: e => handleExampleChange(e.target.value), disabled: isChangingExample, style: {
+                                        padding: '6px 12px',
+                                        fontSize: '14px',
+                                        border: '1px solid #ccc',
+                                        borderRadius: '4px',
+                                        background: 'white',
+                                        cursor: isChangingExample ? 'not-allowed' : 'pointer',
+                                        fontFamily: 'monospace',
+                                        minWidth: '250px',
+                                    }, children: getExampleNames()
+                                        .sort()
+                                        .map(name => (_jsx("option", { value: name, children: name }, name))) }), isChangingExample && (_jsx("span", { style: { color: '#666', fontSize: '12px' }, children: "Loading..." })), error && (_jsxs("span", { style: { color: '#dc3545', fontSize: '12px' }, children: ["Error: ", error] }))] }), _jsx("img", { src: "https://assets.datalayer.tech/datalayer-25.svg", alt: "Datalayer", style: { height: '24px' } })] }), _jsx("div", { style: { height: 'calc(100vh - 50px)', overflow: 'auto' }, children: isChangingExample ? (_jsxs("div", { style: { padding: '40px', textAlign: 'center', color: '#666' }, children: [_jsxs("h3", { children: ["Loading ", selectedExample, "..."] }), _jsx("p", { children: "Please wait while the example loads." })] })) : ExampleComponent ? (_jsx(ExampleComponent, { ...exampleProps })) : null })] }) }));
+};
+// Mount the app - check route to determine which app to render
+const root = document.getElementById('root');
+if (root) {
+    if (isNotebookOnlyRoute()) {
+        console.warn('[DEBUG] Rendering NotebookOnlyApp');
+        createRoot(root).render(_jsx(NotebookOnlyApp, {}));
+    }
+    else {
+        console.warn('[DEBUG] Rendering ExampleApp');
+        createRoot(root).render(_jsx(ExampleApp, {}));
+    }
+}
+else {
+    console.error('Root element not found');
+}

package/lib/examples2/notebooks/IPyWidgetsExample.ipynb.json

@@ -0,0 +1,101 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "3a86eccf-352d-480d-b1b0-4cf355921be9",
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "c686864a5ad44793b53c9cf1b112fafe",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": []
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": ["import ipywidgets as widgets\n", "widgets.IntSlider()"]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "id": "f347e0ac-7614-4643-8fed-e6b5dfb67bcd",
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "e361a274319a4715ae5cfc8104c87224",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": ["FloatText(value=0.0)"]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "859ac1871f56461fa8f2c97e6e18c4c4",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": ["FloatSlider(value=0.0)"]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "from IPython.display import display\n",
+        "a = widgets.FloatText()\n",
+        "b = widgets.FloatSlider()\n",
+        "display(a,b)\n",
+        "mylink = widgets.jslink((a, 'value'), (b, 'value'))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "id": "07f52271-ccae-476d-83b9-715c96168c7c",
+      "metadata": {},
+      "outputs": [],
+      "source": ["mylink.unlink()"]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "81b15288-063d-412d-99db-c73453e18565",
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.11.4"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

package/lib/examples2/notebooks/IPyWidgetsExampleWithState.ipynb.json

@@ -0,0 +1,112 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "58fc6682",
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "68c218b87d4d43589628d4f23e112319",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": ["IntSlider(value=0)"]
+          },
+          "execution_count": 1,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": ["import ipywidgets\n", "ipywidgets.IntSlider()"]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "5af4e4a9",
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.10.13"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "state": {
+          "1a916ae14b904353bc5f2db9714a8f2b": {
+            "model_module": "@jupyter-widgets/base",
+            "model_module_version": "2.0.0",
+            "model_name": "LayoutModel",
+            "state": {}
+          },
+          "32c74c0d7a7a4bbe84039bb47cc032d6": {
+            "model_module": "@jupyter-widgets/controls",
+            "model_module_version": "2.0.0",
+            "model_name": "IntSliderModel",
+            "state": {
+              "behavior": "drag-tap",
+              "layout": "IPY_MODEL_6753cb5249ae4429b1d0aaf7af2ef7c1",
+              "style": "IPY_MODEL_f18c172d32f54e0b810ff0725b827fdf",
+              "value": 33
+            }
+          },
+          "39beda15640c4c3fa82a284dc7df1235": {
+            "model_module": "@jupyter-widgets/controls",
+            "model_module_version": "2.0.0",
+            "model_name": "SliderStyleModel",
+            "state": {
+              "description_width": ""
+            }
+          },
+          "6753cb5249ae4429b1d0aaf7af2ef7c1": {
+            "model_module": "@jupyter-widgets/base",
+            "model_module_version": "2.0.0",
+            "model_name": "LayoutModel",
+            "state": {}
+          },
+          "68c218b87d4d43589628d4f23e112319": {
+            "model_module": "@jupyter-widgets/controls",
+            "model_module_version": "2.0.0",
+            "model_name": "IntSliderModel",
+            "state": {
+              "behavior": "drag-tap",
+              "layout": "IPY_MODEL_1a916ae14b904353bc5f2db9714a8f2b",
+              "style": "IPY_MODEL_39beda15640c4c3fa82a284dc7df1235"
+            }
+          },
+          "f18c172d32f54e0b810ff0725b827fdf": {
+            "model_module": "@jupyter-widgets/controls",
+            "model_module_version": "2.0.0",
+            "model_name": "SliderStyleModel",
+            "state": {
+              "description_width": ""
+            }
+          }
+        },
+        "version_major": 2,
+        "version_minor": 0
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

package/lib/examples2/notebooks/Lite.ipynb.json

@@ -0,0 +1,128 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": ["'Emscripten'"]
+          },
+          "execution_count": 1,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": ["import platform\n", "platform.system()"]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": ["emscripten"]
+          },
+          "execution_count": 1,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": ["import sys\n", "sys.platform"]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "<pyodide_kernel.interpreter.Interpreter at 0x22906f0>"
+            ]
+          },
+          "execution_count": 1,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": ["get_ipython()"]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": ["4"]
+          },
+          "execution_count": 1,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": ["# I am a Python cell.\n", "print('2+2')"]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "execution_count": 1,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": ["import micropip\n", "await micropip.install('ipywidgets')"]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "execution_count": 1,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": ["from ipywidgets import IntSlider\n", "w = IntSlider()\n", "w"]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "execution_count": 1,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": ["w"]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {},
+  "nbformat": 4,
+  "nbformat_minor": 4
+}