Merge pull request #122 from ericsnekbytes/signals_refactor

Continue signal refactors.

Author: RRosio

jupyter_fsspec/file_manager.py

@@ -115,6 +115,21 @@ def _get_protocol_from_path(path):
         protocol = storage_options.get("protocol", "file")
         return protocol
 
+    @staticmethod
+    def construct_fs(fs_protocol, asynchronous, *args, **kwargs):
+        return fsspec.filesystem(
+            fs_protocol, asynchronous=asynchronous, *args, **kwargs
+        )
+
+    def construct_named_fs(self, fs_name, asynchronous=False):
+        if fs_name in self.filesystems:
+            fs_info = self.filesystems[fs_name]
+            fs_protocol = fs_info["protocol"]
+            return FileSystemManager.construct_fs(
+                fs_protocol, asynchronous, *fs_info["args"], **fs_info["kwargs"]
+            )
+        return None
+
     def initialize_filesystems(self):
         new_filesystems = {}
 
@@ -139,21 +154,34 @@ def initialize_filesystems(self):
 
             key = self._encode_key(fs_config)
 
+            # Store the filesystem instance
+            fs_info = {
+                "instance": None,
+                "name": fs_name,
+                "protocol": fs_protocol,
+                "path": None,
+                "canonical_path": None,
+                "args": args,
+                "kwargs": kwargs,
+            }
+            new_filesystems[key] = fs_info
             fs_class = fsspec.get_filesystem_class(fs_protocol)
             if fs_class.async_impl:
-                fs = fsspec.filesystem(fs_protocol, asynchronous=True, *args, **kwargs)
+                fs = FileSystemManager.construct_fs(fs_protocol, True, *args, **kwargs)
+                fs_info["instance"] = fs
+
+                fs_info["path"] = fs._strip_protocol(fs_path)
+                fs_info["canonical_path"] = fs.unstrip_protocol(fs_path)
             else:
-                sync_fs = fsspec.filesystem(fs_protocol, *args, **kwargs)
+                sync_fs = FileSystemManager.construct_fs(
+                    fs_protocol, False, *args, **kwargs
+                )
                 fs = AsyncFileSystemWrapper(sync_fs)
+                fs_info["instance"] = fs
+
+                fs_info["path"] = fs._strip_protocol(fs_path)
+                fs_info["canonical_path"] = fs.unstrip_protocol(fs_path)
 
-            # Store the filesystem instance
-            new_filesystems[key] = {
-                "instance": fs,
-                "name": fs_name,
-                "protocol": fs_protocol,
-                "path": fs._strip_protocol(fs_path),
-                "canonical_path": fs.unstrip_protocol(fs_path),
-            }
             logger.debug(
                 f"Initialized filesystem '{fs_name}' with protocol '{fs_protocol}' at path '{fs_path}'"
             )

jupyter_fsspec/helper.py

@@ -117,9 +117,9 @@ def _get_fs(fs_name):
     # Get an fsspec filesystem from the manager
     # The fs_name is url encoded, we handle that here...TODO refactor that
     mgr = _get_manager()
-    fs = mgr.get_filesystem(fs_name)
-    if fs is not None and "instance" in fs:
-        return fs["instance"]  # TODO refactor
+    fs = mgr.construct_named_fs(fs_name)
+    if fs is not None:
+        return fs
     else:
         raise JupyterFsspecException("Error, could not find specified filesystem")
 

package.json

@@ -65,6 +65,8 @@
         "@jupyterlab/filebrowser": "^4.0.0",
         "@jupyterlab/settingregistry": "^4.0.0",
         "@jupyterlab/ui-components": "^4.0.0",
+        "@lumino/signaling": "^2.0.0",
+        "@lumino/widgets": "^2.5.0",
         "buffer": "^6.0.3",
         "path": "^0.12.7",
         "react": "^18.3.1",
@@ -95,6 +97,7 @@
         "stylelint-csstree-validator": "^3.0.0",
         "stylelint-prettier": "^4.0.0",
         "typescript": "~5.0.2",
+        "util": "^0.12.5",
         "yjs": "^13.5.0"
     },
     "resolutions": {

src/FssTreeItem.ts

@@ -5,6 +5,8 @@ import {
   jpTreeItem
 } from '@jupyter/web-components';
 
+import { Signal } from '@lumino/signaling';
+
 import { INotebookTracker } from '@jupyterlab/notebook';
 
 import { fileIcon, folderIcon } from '@jupyterlab/ui-components';
@@ -20,27 +22,18 @@ export class FssTreeItem {
   sizeLbl: HTMLElement;
   dirSymbol: HTMLElement;
   container: HTMLElement;
-  clickSlots: any;
-  getBytesSlots: any;
-  uploadUserDataSlots: any;
-  uploadFromBrowserPickerSlots: any;
-  uploadFromJupyterBrowserSlots: any;
   isDir = false;
   treeItemObserver: MutationObserver;
   pendingExpandAction = false;
   lazyLoadAutoExpand = true;
   clickAnywhereDoesAutoExpand = true;
   notebookTracker: INotebookTracker;
+  treeItemClicked: Signal<any, string>;
+  getBytesRequested: Signal<any, string>;
+  uploadRequested: Signal<any, any>; // All upload requests go here (kernel user_data, browser picker etc.)
 
   constructor(
     model: any,
-    clickSlots: any,
-    userGetBytesSlots: any,
-    uploadUserDataSlots: any,
-
-    uploadFromBrowserPickerSlots: any,
-    uploadFromJupyterBrowserSlots: any,
-
     autoExpand: boolean,
     expandOnClickAnywhere: boolean,
     notebookTracker: INotebookTracker
@@ -56,14 +49,12 @@ export class FssTreeItem {
     root.setAttribute('name', 'jfss-treeitem-root');
     this.root = root;
     this.model = model;
-    this.clickSlots = clickSlots;
-    this.getBytesSlots = userGetBytesSlots; // TODO fix its horrible
-    this.uploadUserDataSlots = uploadUserDataSlots;
-    this.uploadFromBrowserPickerSlots = uploadFromBrowserPickerSlots;
-    this.uploadFromJupyterBrowserSlots = uploadFromJupyterBrowserSlots;
     this.lazyLoadAutoExpand = autoExpand;
     this.clickAnywhereDoesAutoExpand = expandOnClickAnywhere;
     this.notebookTracker = notebookTracker;
+    this.treeItemClicked = new Signal<this, string>(this);
+    this.getBytesRequested = new Signal<this, string>(this);
+    this.uploadRequested = new Signal<this, any>(this);
 
     // Use a MutationObserver on the root TreeItem's shadow DOM,
     // where the TreeItem's expand/collapse control will live once
@@ -119,30 +110,12 @@ export class FssTreeItem {
 
   handleRequestBytes() {
     Logger.debug('Treeitem get bytes');
-    for (const slot of this.getBytesSlots) {
-      Logger.debug(slot);
-      slot(this.root.dataset.fss);
-    }
-  }
-
-  async handleUploadFromBrowserPicker(options: any) {
-    this.model.queuedPickerUploadInfo = {}; // Context click always resets this data
-    Logger.debug('Treeitem upload user data');
-    for (const slot of this.uploadFromBrowserPickerSlots) {
-      Logger.debug(slot);
-      await slot(this.root.dataset.fss, this.isDir);
-    }
+    this.getBytesRequested.emit(this.root.dataset.fss);
   }
 
-  async handleUploadFromJupyterBrowser(options: any) {
-    Logger.debug('Treeitem upload user data');
-    for (const slot of this.uploadFromJupyterBrowserSlots) {
-      Logger.debug(slot);
-      await slot(this.root.dataset.fss, this.isDir);
-    }
-  }
-
-  async handleUploadUserData(options: any) {
+  async handleUploadRequest(options: any) {
+    // Uploads can come from different places, gather info and emit it here
+    // (so that connected slots can route the request to the right place)
     let is_browser_file_picker = false;
     let is_jup_browser_file = false;
     if (options) {
@@ -151,15 +124,12 @@ export class FssTreeItem {
       this.model.queuedPickerUploadInfo = {}; // Context click always resets this data
     }
     Logger.debug('Treeitem upload user data');
-    for (const slot of this.uploadUserDataSlots) {
-      Logger.debug(slot);
-      await slot(
-        this.root.dataset.fss,
-        this.isDir,
-        is_browser_file_picker,
-        is_jup_browser_file
-      );
-    }
+    this.uploadRequested.emit({
+      user_path: this.root.dataset.fss,
+      is_dir: this.isDir,
+      is_browser_file_picker: is_browser_file_picker,
+      is_jup_browser_file: is_jup_browser_file
+    });
   }
 
   setMetadata(user_path: string, size: string) {
@@ -250,9 +220,7 @@ export class FssTreeItem {
       }
       // Fire connected slots that were supplied to this item on init
       if (this.isDir) {
-        for (const slot of this.clickSlots) {
-          slot(this.root.dataset.fss);
-        }
+        this.treeItemClicked.emit(this.root.dataset.fss);
       } else {
         this.root.click();
       }

src/FssTreeItemContext.ts

@@ -104,6 +104,7 @@ export class FssTreeItemContext {
       }
     }
   }
+
   copyOpenCodeBlock() {
     const path = this.copyPath();
 
@@ -129,7 +130,7 @@ export class FssTreeItemContext {
   }
 
   handleItemClick(event: any) {
-    // TODO multiple menu it
+    console.log('sig1');
     if (event.target.dataset.fssContextType === 'copyPath') {
       this.copyPathToClipboard();
     } else if (event.target.dataset.fssContextType === 'copyOpenCodeBlock') {
@@ -143,12 +144,13 @@ export class FssTreeItemContext {
     } else if (event.target.dataset.fssContextType === 'uploadUserData') {
       Logger.debug('XX1');
       if (this.parentControl) {
-        this.parentControl.handleUploadUserData();
+        this.parentControl.handleUploadRequest();
       }
     } else if (event.target.dataset.fssContextType === 'uploadBrowserFile') {
       Logger.debug('XX2');
+      console.log('sig2');
       if (this.parentControl) {
-        this.parentControl.handleUploadFromBrowserPicker({
+        this.parentControl.handleUploadRequest({
           is_browser_file_picker: true
         });
       }
@@ -157,13 +159,15 @@ export class FssTreeItemContext {
     ) {
       Logger.debug('XX3');
       if (this.parentControl) {
-        this.parentControl.handleUploadFromJupyterBrowser({
+        this.parentControl.handleUploadRequest({
           is_jup_browser_file: true
         });
       }
     }
 
+    console.log('sig3');
     this.root.remove();
+    console.log('sig4');
   }
 
   handleItemHover(event: any) {