jupyterpack 0.3.0 → 0.4.0

package/src/pythonWidget/comm.ts

@@ -0,0 +1,65 @@
+import { Kernel, KernelMessage } from '@jupyterlab/services';
+
+const COMM_NAME = 'jupyterpack:broadcast:comm';
+
+export class CommBroadcastManager {
+  constructor() {
+    this._kernels = new Map();
+    this._comms = new Map();
+  }
+
+  registerKernel(kernel: Kernel.IKernelConnection) {
+    this._kernels.set(kernel.id, kernel);
+    kernel.registerCommTarget(COMM_NAME, (comm, msg) =>
+      this._handle_comm_open(comm, msg, kernel.id)
+    );
+  }
+  unregisterKernel(kernelId?: string) {
+    if (kernelId) {
+      this._kernels.delete(kernelId);
+      const comms = this._comms.get(kernelId) ?? [];
+      comms.forEach(comm => comm.dispose());
+      this._comms.delete(kernelId);
+    }
+  }
+
+  private _handle_comm_open = async (
+    comm: Kernel.IComm,
+    msg: KernelMessage.ICommOpenMsg,
+    kernelId: string
+  ): Promise<void> => {
+    if (this._comms.has(kernelId)) {
+      this._comms.get(kernelId)?.push(comm);
+    } else {
+      this._comms.set(kernelId, [comm]);
+    }
+    const channelName = msg.metadata.channel_name as string | undefined;
+    if (!channelName) {
+      return;
+    }
+    if (!this._broadcastChannels.has(channelName)) {
+      this._broadcastChannels.set(
+        channelName,
+        new BroadcastChannel(channelName)
+      );
+    }
+    const broadcastChannel = this._broadcastChannels.get(channelName)!;
+    comm.onMsg = commMsg => {
+      const { data } = commMsg.content;
+      broadcastChannel.postMessage(data);
+    };
+  };
+
+  dispose() {
+    this._kernels.clear();
+    this._comms.clear();
+    this._broadcastChannels.forEach(it => {
+      it.close();
+    });
+    this._broadcastChannels.clear();
+  }
+
+  private _kernels: Map<string, Kernel.IKernelConnection> = new Map();
+  private _comms: Map<string, Kernel.IComm[]> = new Map();
+  private _broadcastChannels: Map<string, BroadcastChannel> = new Map();
+}

package/src/pythonWidget/pythonWidget.ts

@@ -1,6 +1,7 @@
 import { PythonWidgetModel } from './pythonWidgetModel';
 import { PageConfig, URLExt } from '@jupyterlab/coreutils';
 import { IFramePanel } from '../document/iframePanel';
+import { PromiseDelegate } from '@lumino/coreutils';
 
 export class PythonWidget extends IFramePanel {
   constructor(options: PythonWidget.IOptions) {
@@ -12,6 +13,7 @@ export class PythonWidget extends IFramePanel {
         this._iframe.contentDocument!.body.innerText = `Failed to start server: ${connectionData.error}`;
         return;
       }
+      this._isReady.resolve();
       const iframe = this._iframe;
       const fullLabextensionsUrl = PageConfig.getOption('fullLabextensionsUrl');
 
@@ -23,24 +25,40 @@ export class PythonWidget extends IFramePanel {
         connectionData.kernelClientId,
         connectionData.rootUrl
       );
-
       iframe.src = iframeUrl;
 
       iframe.addEventListener('load', () => {
         this.toggleSpinner(false);
       });
+      this._model.serverReloaded.connect(() => {
+        this._iframe?.contentWindow?.location?.reload();
+      });
     });
   }
 
+  get autoreload() {
+    return this._model.autoreload;
+  }
+  set autoreload(value: boolean) {
+    this._model.autoreload = value;
+  }
+  get isReady(): Promise<void> {
+    return this._isReady.promise;
+  }
   get model(): PythonWidgetModel {
     return this._model;
   }
 
+  async reload(): Promise<void> {
+    await this._model.reload();
+  }
+
   dispose(): void {
     this._model.dispose();
   }
 
   private _model: PythonWidgetModel;
+  private _isReady = new PromiseDelegate<void>();
 }
 
 export namespace PythonWidget {

package/src/pythonWidget/pythonWidgetModel.ts

@@ -7,31 +7,64 @@ import {
   Session
 } from '@jupyterlab/services';
 import { PromiseDelegate } from '@lumino/coreutils';
-import { IDisposable } from '@lumino/disposable';
 
 import { PYTHON_SERVER } from '../pythonServer';
+import { Signal } from '@lumino/signaling';
 import {
   IConnectionManager,
   IJupyterPackFileFormat,
   IKernelExecutor,
+  IPythonWidgetModel,
   JupyterPackFramework
 } from '../type';
+import { CommBroadcastManager } from './comm';
+import { IS_LITE } from '../tools';
 
-export class PythonWidgetModel implements IDisposable {
+export class PythonWidgetModel implements IPythonWidgetModel {
   constructor(options: PythonWidgetModel.IOptions) {
     this._context = options.context;
     this._manager = options.manager;
     this._connectionManager = options.connectionManager;
     this._contentsManager = options.contentsManager;
     this._jpackModel = options.jpackModel;
+    this._localPath = PathExt.dirname(this._context.localPath);
+    this._autoreload = Boolean(this._jpackModel?.metadata?.autoreload);
+
+    this._contentsManager.fileChanged.connect(this._onFileChanged, this);
+  }
+
+  get autoreload() {
+    return this._autoreload;
   }
 
+  set autoreload(val: boolean) {
+    this._autoreload = val;
+  }
   get isDisposed(): boolean {
     return this._isDisposed;
   }
   get connectionManager(): IConnectionManager {
     return this._connectionManager;
   }
+  get serverReloaded() {
+    return this._serverReloaded;
+  }
+  get kernelStatusChanged() {
+    return this._kernelStatusChanged;
+  }
+
+  async reload() {
+    if (!this._kernelStarted) {
+      return;
+    }
+    const { spkContent, entryContent } = await this._loadData();
+    await this._executor?.reloadPythonServer({
+      entryPath: spkContent.entry,
+      initCode: entryContent.content
+    });
+    this._serverReloaded.emit();
+  }
+
   async initialize(): Promise<
     | {
         success: true;
@@ -48,15 +81,9 @@ export class PythonWidgetModel implements IDisposable {
         error: 'Server is called twice'
       };
     }
-    const filePath = this._context.localPath;
-    const spkContent = this._jpackModel;
 
-    const entryPath = PathExt.join(PathExt.dirname(filePath), spkContent.entry);
-    const rootUrl = spkContent.rootUrl ?? '/';
-    const entryContent = await this._contentsManager.get(entryPath, {
-      content: true,
-      format: 'text'
-    });
+    const { filePath, spkContent, rootUrl, entryContent } =
+      await this._loadData();
     const sessionManager = this._manager.sessions;
     await sessionManager.ready;
     await this._manager.kernelspecs.ready;
@@ -73,14 +100,29 @@ export class PythonWidgetModel implements IDisposable {
       kernelName = specs.default;
     }
 
-    this._sessionConnection = await sessionManager.startNew({
-      name: filePath,
-      path: filePath,
-      kernel: {
-        name: kernelName
+    this._sessionConnection = await sessionManager.startNew(
+      {
+        name: filePath,
+        path: filePath,
+        kernel: {
+          name: kernelName
+        },
+        type: 'notebook'
       },
-      type: 'notebook'
-    });
+      {
+        kernelConnectionOptions: { handleComms: true }
+      }
+    );
+    const kernel = this._sessionConnection.kernel;
+    if (kernel) {
+      this._kernelStatusChanged.emit('started');
+      this._commBroadcastManager.registerKernel(kernel);
+      kernel.disposed.connect(() => {
+        this._kernelStatusChanged.emit('stopped');
+        this._commBroadcastManager.unregisterKernel(kernel.id);
+      });
+    }
+
     const framework = spkContent.framework;
     const ServerClass = PYTHON_SERVER.get(framework);
     if (!ServerClass) {
@@ -111,14 +153,48 @@ export class PythonWidgetModel implements IDisposable {
     this._kernelStarted = true;
     return { ...data, rootUrl, framework, success: true };
   }
-  dispose(): void {
+  async dispose(): Promise<void> {
     if (this._isDisposed) {
       return;
     }
+    if (!IS_LITE) {
+      this._sessionConnection?.kernel?.shutdown();
+    }
     void this._executor?.disposePythonServer();
+    this._contentsManager.fileChanged.disconnect(this._onFileChanged);
+    this._commBroadcastManager.dispose();
     this._isDisposed = true;
   }
 
+  private async _loadData() {
+    const filePath = this._context.localPath;
+    const spkContent = this._jpackModel;
+
+    const entryPath = PathExt.join(PathExt.dirname(filePath), spkContent.entry);
+    const rootUrl = spkContent.rootUrl ?? '/';
+    const entryContent = await this._contentsManager.get(entryPath, {
+      content: true,
+      format: 'text'
+    });
+    return { filePath, spkContent, rootUrl, entryContent };
+  }
+
+  private async _onFileChanged(
+    sender: Contents.IManager,
+    args: Contents.IChangedArgs
+  ) {
+    if (this._autoreload && args.type === 'save') {
+      if (
+        args.newValue?.path &&
+        args.newValue.path.startsWith(this._localPath)
+      ) {
+        await this.reload();
+      }
+    }
+  }
+
+  private _commBroadcastManager = new CommBroadcastManager();
+
   private _isDisposed = false;
   private _kernelStarted = false;
   private _sessionConnection: Session.ISessionConnection | undefined;
@@ -128,6 +204,17 @@ export class PythonWidgetModel implements IDisposable {
   private _contentsManager: Contents.IManager;
   private _jpackModel: IJupyterPackFileFormat;
   private _executor?: IKernelExecutor;
+  private _localPath: string;
+
+  private _serverReloaded: Signal<IPythonWidgetModel, void> = new Signal<
+    IPythonWidgetModel,
+    void
+  >(this);
+  private _kernelStatusChanged: Signal<
+    IPythonWidgetModel,
+    'started' | 'stopped'
+  > = new Signal(this);
+  private _autoreload: boolean;
 }
 
 export namespace PythonWidgetModel {

package/src/sandpackWidget/sandpackFilesModel.ts

@@ -3,16 +3,17 @@ import { ISignal, Signal } from '@lumino/signaling';
 
 import { IDict } from '../type';
 import { removePrefix } from '../tools';
+import { IDisposable } from '@lumino/disposable';
 
-export class SandpackFilesModel {
+export class SandpackFilesModel implements IDisposable {
   constructor(options: { contentsManager: Contents.IManager; path: string }) {
     this._contentManager = options.contentsManager;
     this._path = options.path;
     this._contentManager.fileChanged.connect(this._onFileChanged, this);
   }
 
-  async getAllFiles(): Promise<IDict<{ code: string }>> {
-    if (!this._allFiles) {
+  async getAllFiles(force = false): Promise<IDict<{ code: string }>> {
+    if (!this._allFiles || force) {
       const files = await this._contentManager.get(this._path, {
         content: true
       });
@@ -21,6 +22,9 @@ export class SandpackFilesModel {
 
     return this._allFiles;
   }
+  get isDisposed(): boolean {
+    return this._isDisposed;
+  }
 
   get fileChanged(): ISignal<
     SandpackFilesModel,
@@ -29,6 +33,14 @@ export class SandpackFilesModel {
     return this._fileChanged;
   }
 
+  dispose(): void {
+    if (this._isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
+    this._contentManager.fileChanged.disconnect(this._onFileChanged);
+  }
+
   async flattenDirectory(
     dirContent: Contents.IModel
   ): Promise<IDict<{ code: string }>> {
@@ -138,4 +150,6 @@ export class SandpackFilesModel {
   private _contentManager: Contents.IManager;
 
   private _allFiles?: IDict<{ code: string }>;
+
+  private _isDisposed = false;
 }

package/src/sandpackWidget/sandpackPanel.ts

@@ -7,8 +7,9 @@ import { DocumentRegistry } from '@jupyterlab/docregistry';
 import { Contents } from '@jupyterlab/services';
 
 import { IFramePanel } from '../document/iframePanel';
-import { IDict } from '../type';
+import { IDict, IJupyterPackFileFormat } from '../type';
 import { SandpackFilesModel } from './sandpackFilesModel';
+import { PromiseDelegate } from '@lumino/coreutils';
 
 export class SandpackPanel extends IFramePanel {
   constructor(options: {
@@ -17,17 +18,44 @@ export class SandpackPanel extends IFramePanel {
   }) {
     super();
     this._contentsManager = options.contentsManager;
+    const { context } = options;
     options.context.ready.then(async () => {
-      await this.init(options.context.localPath);
+      const jpackModel =
+        context.model.toJSON() as any as IJupyterPackFileFormat;
+      await this.init(context.localPath, jpackModel);
     });
   }
 
-  async init(localPath: string) {
+  dispose(): void {
+    this._fileModel?.fileChanged.disconnect(this._onFileChanged);
+    this._fileModel?.dispose();
+    this._spClient?.destroy();
+    super.dispose();
+  }
+
+  get isReady() {
+    return this._isReady.promise;
+  }
+
+  get autoreload(): boolean {
+    return this._autoreload;
+  }
+
+  set autoreload(val: boolean) {
+    this._autoreload = val;
+  }
+
+  async init(localPath: string, jpackModel: IJupyterPackFileFormat) {
+    if (jpackModel?.metadata?.autoreload === true) {
+      this._autoreload = true;
+    }
+
     const currentDir = localPath.split('/').slice(0, -1).join('/');
     const filesModel = new SandpackFilesModel({
       contentsManager: this._contentsManager,
       path: currentDir
     });
+    this._fileModel = filesModel;
     const allFiles = await filesModel.getAllFiles();
 
     const options: ClientOptions = {
@@ -43,6 +71,7 @@ export class SandpackPanel extends IFramePanel {
       options
     );
     await this.connectSignals(filesModel, this._spClient);
+    this._isReady.resolve();
   }
 
   async connectSignals(
@@ -66,11 +95,20 @@ export class SandpackPanel extends IFramePanel {
     });
   }
 
+  async reload(): Promise<void> {
+    if (this._spClient && this._fileModel) {
+      const allFiles = await this._fileModel.getAllFiles();
+      this._spClient.updateSandbox({
+        files: allFiles
+      });
+    }
+  }
+
   private _onFileChanged(
     sender: SandpackFilesModel,
     { allFiles }: { allFiles: IDict<{ code: string }> }
   ) {
-    if (this._spClient) {
+    if (this._autoreload && this._spClient) {
       this._spClient.updateSandbox({
         files: allFiles
       });
@@ -79,4 +117,7 @@ export class SandpackPanel extends IFramePanel {
 
   private _spClient?: SandpackClient;
   private _contentsManager: Contents.IManager;
+  private _fileModel: SandpackFilesModel | undefined;
+  private _autoreload = false;
+  private _isReady = new PromiseDelegate<void>();
 }

package/src/token.ts

@@ -1,6 +1,10 @@
 import { Token } from '@lumino/coreutils';
-import { IConnectionManager } from './type';
+import { IConnectionManager, IJupyterpackDocTracker } from './type';
 
 export const IConnectionManagerToken = new Token<IConnectionManager>(
   'jupyterpack:connection-manager'
 );
+
+export const IJupyterpackDocTrackerToken = new Token<IJupyterpackDocTracker>(
+  'jupyterpack:dock-tracker'
+);

package/src/tools.ts

@@ -1,3 +1,25 @@
+import logoStr from '../style/icons/box.svg';
+import autoReloadStr from '../style/icons/autoreload.svg';
+import linkStr from '../style/icons/externallink.svg';
+import { LabIcon } from '@jupyterlab/ui-components';
+
+export const IS_LITE = !!document.getElementById('jupyter-lite-main');
+
+export const logoIcon = new LabIcon({
+  name: 'jupyterpack:logo',
+  svgstr: logoStr
+});
+
+export const autoReloadIcon = new LabIcon({
+  name: 'jupyterpack:autoReload',
+  svgstr: autoReloadStr
+});
+
+export const linkIcon = new LabIcon({
+  name: 'jupyterpack:externalLink',
+  svgstr: linkStr
+});
+
 export function removePrefix(path: string, prefix: string): string {
   if (path.startsWith(prefix)) {
     return path.slice(prefix.length);

package/src/type.ts

@@ -1,5 +1,8 @@
+import { DocumentWidget } from '@jupyterlab/docregistry';
 import { KernelMessage } from '@jupyterlab/services';
 import { IDisposable } from '@lumino/disposable';
+import { IWidgetTracker } from '@jupyterlab/apputils';
+import { ISignal } from '@lumino/signaling';
 
 export interface IDict<T = any> {
   [key: string]: T;
@@ -29,7 +32,9 @@ export interface IJupyterPackFileFormat {
   entry: string;
   framework: JupyterPackFramework;
   name?: string;
-  metadata?: IDict;
+  metadata?: {
+    autoreload?: boolean;
+  };
   rootUrl?: string;
 }
 
@@ -69,6 +74,10 @@ export interface IKernelExecutor extends IDisposable {
     kernelClientId: string;
   }): Promise<void>;
   disposePythonServer(): Promise<void>;
+  reloadPythonServer(options: {
+    entryPath?: string;
+    initCode?: string;
+  }): Promise<void>;
   getResponseFunctionFactory(options: {
     urlPath: string;
     method: string;
@@ -86,3 +95,22 @@ export interface IConnectionManager {
     option: { kernelClientId: string } & IKernelExecutorParams
   ): Promise<IDict | null>;
 }
+
+export type IJupyterpackDocTracker = IWidgetTracker<DocumentWidget>;
+
+export interface IPythonWidgetModel extends IDisposable {
+  connectionManager: IConnectionManager;
+  serverReloaded: ISignal<IPythonWidgetModel, void>;
+  kernelStatusChanged: ISignal<IPythonWidgetModel, 'started' | 'stopped'>;
+  reload(): Promise<void>;
+  initialize(): Promise<
+    | {
+        success: true;
+        instanceId: string;
+        kernelClientId: string;
+        rootUrl: string;
+        framework: JupyterPackFramework;
+      }
+    | { success: false; error: string }
+  >;
+}

package/style/base.css

@@ -49,3 +49,10 @@
       0 0 0 0 rgb(212 72 13 / 100%);
   }
 }
+
+.specta-main-content-panel .jupyterpack-toolbar {
+  display: none;
+  height: 0 !important;
+  width: 0 !important;
+  min-height: 0 !important;
+}

package/style/icons/autoreload.svg

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<svg height="800px" width="800px" viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg">
+	<g>
+		<path d="M403.925,108.102c-27.595-27.595-62.899-47.558-102.459-56.29L304.182,0L201.946,53.867l-27.306,14.454
+		l-5.066,2.654l8.076,4.331l38.16,20.542l81.029,43.602l2.277-42.859c28.265,7.546,53.438,22.53,73.623,42.638
+		c29.94,29.939,48.358,71.119,48.358,116.776c0,23.407-4.843,45.58-13.575,65.687l40.37,17.532
+		c11.076-25.463,17.242-53.637,17.242-83.219C465.212,198.306,441.727,145.904,403.925,108.102z"
+			fill="var(--jp-inverse-layout-color3)" />
+		<path d="M296.256,416.151l-81.101-43.612l-2.272,42.869c-28.26-7.555-53.51-22.53-73.618-42.636
+		c-29.945-29.95-48.364-71.12-48.364-116.767c0-23.427,4.844-45.522,13.576-65.697l-40.37-17.531
+		c-11.076,25.53-17.242,53.723-17.242,83.228c0,57.679,23.407,110.157,61.21,147.893c27.595,27.594,62.899,47.548,102.453,56.202
+		l-2.716,51.9l102.169-53.878l27.455-14.454l4.988-2.643l-7.999-4.332L296.256,416.151z"
+			fill="var(--jp-inverse-layout-color3)" />
+	</g>
+</svg>

package/style/icons/box.svg

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M17.5777 4.43152L15.5777 3.38197C13.8221 2.46066 12.9443 2 12 2C11.0557 2 10.1779 2.46066 8.42229 3.38197L6.42229 4.43152C4.64855 5.36234 3.6059 5.9095 2.95969 6.64132L12 11.1615L21.0403 6.64132C20.3941 5.9095 19.3515 5.36234 17.5777 4.43152Z"
+    fill="var(--jp-inverse-layout-color3)" />
+  <path
+    d="M21.7484 7.96435L12.75 12.4635V21.904C13.4679 21.7252 14.2848 21.2965 15.5777 20.618L17.5777 19.5685C19.7294 18.4393 20.8052 17.8748 21.4026 16.8603C22 15.8458 22 14.5833 22 12.0585V11.9415C22 10.0489 22 8.86558 21.7484 7.96435Z"
+    fill="var(--jp-inverse-layout-color3)" />
+  <path
+    d="M11.25 21.904V12.4635L2.25164 7.96434C2 8.86557 2 10.0489 2 11.9415V12.0585C2 14.5833 2 15.8458 2.5974 16.8603C3.19479 17.8748 4.27063 18.4393 6.42229 19.5685L8.42229 20.618C9.71524 21.2965 10.5321 21.7252 11.25 21.904Z"
+    fill="var(--jp-inverse-layout-color3)" />
+</svg>

package/style/icons/externallink.svg

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <g>
+    <path id="Vector"
+      d="M10.0002 5H8.2002C7.08009 5 6.51962 5 6.0918 5.21799C5.71547 5.40973 5.40973 5.71547 5.21799 6.0918C5 6.51962 5 7.08009 5 8.2002V15.8002C5 16.9203 5 17.4801 5.21799 17.9079C5.40973 18.2842 5.71547 18.5905 6.0918 18.7822C6.5192 19 7.07899 19 8.19691 19H15.8031C16.921 19 17.48 19 17.9074 18.7822C18.2837 18.5905 18.5905 18.2839 18.7822 17.9076C19 17.4802 19 16.921 19 15.8031V14M20 9V4M20 4H15M20 4L13 11"
+      stroke="var(--jp-inverse-layout-color3)" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+  </g>
+</svg>

package/lib/pythonServer/common/generatedPythonFiles.d.ts

@@ -1,2 +0,0 @@
-export declare const patch = "\nimport pyodide_http\nimport collections\n\nif not hasattr(collections, \"MutableSet\"):\n    import collections.abc\n\n    collections.MutableSet = collections.abc.MutableSet\n\npyodide_http.patch_all()";
-export declare const tools = "\nimport importlib.util\nimport sys\nfrom types import ModuleType\n\nimport tempfile\nfrom pathlib import Path\nfrom typing import List\nimport os\n\nos.environ.setdefault(\"JUPYTERPACK_BASE_URL\", \"{{base_url}}\")\n\n\ndef __jupyterpack_import_from_path(module_name: str, path: str) -> ModuleType:\n    \"\"\"\n    Import a Python module from a given file path.\n    Always reloads (does not use sys.modules cache).\n    \"\"\"\n    # Remove from sys.modules if already loaded\n    if module_name in sys.modules:\n        del sys.modules[module_name]\n\n    spec = importlib.util.spec_from_file_location(module_name, path)\n    if spec is None or spec.loader is None:\n        raise ImportError(f\"Cannot import module {module_name} from {path}\")\n\n    module = importlib.util.module_from_spec(spec)\n    sys.modules[module_name] = module\n    spec.loader.exec_module(module)\n    return module\n\n\ndef __jupyterpack_create_mock_module(\n    module_names: List[str], mock_content: str, patch_parent=True\n):\n    tmpdir = tempfile.TemporaryDirectory()\n    package_dir = Path(tmpdir.name) / \"__jupyterpack_mock_module\"\n    package_dir.mkdir()\n    (package_dir / \"__init__.py\").write_text(mock_content)\n\n    sys.path.insert(0, tmpdir.name)\n    mock_module = importlib.import_module(\"__jupyterpack_mock_module\")\n    sys.path.pop(0)\n    for module_name in module_names:\n        if patch_parent:\n            parts = module_name.split(\".\")\n            for i in range(1, len(parts) + 1):\n                subpath = \".\".join(parts[:i])\n                sys.modules[subpath] = mock_module\n\n            for i in range(1, len(parts)):\n                parent_name = \".\".join(parts[:i])\n                child_name = \".\".join(parts[: i + 1])\n                parent_mod = sys.modules[parent_name]\n                child_mod = sys.modules[child_name]\n                setattr(parent_mod, parts[i], child_mod)\n        else:\n            sys.modules[module_name] = mock_module\n\n    return tmpdir\n";

package/lib/pythonServer/common/generatedPythonFiles.js

@@ -1,72 +0,0 @@
-// Auto-generated TypeScript file from Python files
-export const patch = `
-import pyodide_http
-import collections
-
-if not hasattr(collections, "MutableSet"):
-    import collections.abc
-
-    collections.MutableSet = collections.abc.MutableSet
-
-pyodide_http.patch_all()`;
-export const tools = `
-import importlib.util
-import sys
-from types import ModuleType
-
-import tempfile
-from pathlib import Path
-from typing import List
-import os
-
-os.environ.setdefault("JUPYTERPACK_BASE_URL", "{{base_url}}")
-
-
-def __jupyterpack_import_from_path(module_name: str, path: str) -> ModuleType:
-    """
-    Import a Python module from a given file path.
-    Always reloads (does not use sys.modules cache).
-    """
-    # Remove from sys.modules if already loaded
-    if module_name in sys.modules:
-        del sys.modules[module_name]
-
-    spec = importlib.util.spec_from_file_location(module_name, path)
-    if spec is None or spec.loader is None:
-        raise ImportError(f"Cannot import module {module_name} from {path}")
-
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-def __jupyterpack_create_mock_module(
-    module_names: List[str], mock_content: str, patch_parent=True
-):
-    tmpdir = tempfile.TemporaryDirectory()
-    package_dir = Path(tmpdir.name) / "__jupyterpack_mock_module"
-    package_dir.mkdir()
-    (package_dir / "__init__.py").write_text(mock_content)
-
-    sys.path.insert(0, tmpdir.name)
-    mock_module = importlib.import_module("__jupyterpack_mock_module")
-    sys.path.pop(0)
-    for module_name in module_names:
-        if patch_parent:
-            parts = module_name.split(".")
-            for i in range(1, len(parts) + 1):
-                subpath = ".".join(parts[:i])
-                sys.modules[subpath] = mock_module
-
-            for i in range(1, len(parts)):
-                parent_name = ".".join(parts[:i])
-                child_name = ".".join(parts[: i + 1])
-                parent_mod = sys.modules[parent_name]
-                child_mod = sys.modules[child_name]
-                setattr(parent_mod, parts[i], child_mod)
-        else:
-            sys.modules[module_name] = mock_module
-
-    return tmpdir
-`;