Fix submit stage file browser (#74)

* Initial fix for environment variables file browser

* fix submit stage file browser

* --Multifile write updated to skip existing files

* style changes to the file browser and file selector

* --modified so working directory will be a name/timestamp directory within the user-defined directory

* --finished debugging current iteration of user execution directory specification

* update tooltip text

---------

Co-authored-by: rdgsllw8 <[email protected]>

Author: sdc50

uit/gui_tools/__init__.py

@@ -16,6 +16,7 @@
 )
 from .file_browser import (
     get_js_loading_code,
+    create_file_browser,
     FileBrowser,
     FileManager,
     FileManagerHPC,

uit/gui_tools/file_browser.py

@@ -183,10 +183,12 @@ class FileBrowser(Viewer):
 
     path = param.ClassSelector(class_=Path, precedence=-1)
     path_text = param.String(label="", precedence=0.3)
-    home = param.Action(lambda self: self.go_home(), label="🏠", precedence=0.1)
-    up = param.Action(lambda self: self.move_up(), label="⬆️", precedence=0.2)
+    home = param.Action(lambda self: self.go_home(), label="🏠", doc="Home", precedence=0.1)
+    up = param.Action(lambda self: self.move_up(), label="⬆️", doc="Move Up", precedence=0.2)
     # refresh_controll triggers rather than calling validate directly to allow an async override of the validate method
-    refresh_control = param.Action(lambda self: self.param.trigger("refresh_control"), label="🔄", precedence=0.25)
+    refresh_control = param.Action(
+        lambda self: self.param.trigger("refresh_control"), label="🔄", doc="Refresh", precedence=0.25
+    )
     callback = param.Action(lambda x: None, precedence=-1)
     file_listing = param.ListSelector(default=[], label="Single click to select a file or directory:", precedence=0.5)
     patterns = param.List(precedence=-1, default=["*"])
@@ -591,7 +593,7 @@ async def exists(self):
 
 class HpcFileBrowser(FileBrowser):
     path = param.ClassSelector(class_=HpcPath)
-    workdir = param.Action(lambda self: self.go_to_workdir(), label="⚙️", precedence=0.15)
+    workdir = param.Action(lambda self: self.go_to_workdir(), label="⚙️", doc="Workdir", precedence=0.15)
     uit_client = param.ClassSelector(class_=Client)
 
     def __init__(self, uit_client, **params):
@@ -683,10 +685,17 @@ async def make_options(self):
         self.do_callback()
 
 
+def create_file_browser(uit_client, **kwargs):
+    if isinstance(uit_client, AsyncClient):
+        return AsyncHpcFileBrowser(uit_client, **kwargs)
+    if isinstance(uit_client, Client):
+        return HpcFileBrowser(uit_client, **kwargs)
+
+
 class FileSelector(Viewer):
     file_path = param.String(default="")
     show_browser = param.Boolean(default=False)
-    browse_toggle = param.Action(lambda self: self.toggle(), label="Browse")
+    browse_toggle = param.Action(lambda self: self.toggle(), label="📂", doc="Open file browser.")
     file_browser = param.ClassSelector(class_=FileBrowser)
     title = param.String(default="File Path")
     help_text = param.String()
@@ -698,14 +707,22 @@ def __init__(self, disabled=False, **params):
         self.file_browser = self.file_browser or FileBrowser(delayed_init=True)
         self.update_file(True)
         self.disabled = disabled
-        # self.param.file_path.label = self.title
+        self.param.file_path.label = self.title
+        self.param.file_path.doc = self.help_text
         self._layout = pn.Column(
             self.input_row,
-            pn.pane.HTML(f'<span style="font-style: italic;">{self.help_text}</span>'),
             self.file_browser_container,
             sizing_mode="stretch_width",
         )
 
+    @param.depends("title", watch=True)
+    def update_title(self):
+        self.param.file_path.label = self.title
+
+    @param.depends("help_text", watch=True)
+    def update_help_text(self):
+        self.param.file_path.doc = self.help_text
+
     @param.depends("disabled", watch=True)
     def update_disabled(self):
         for p in ["file_path", "browse_toggle"]:
@@ -735,16 +752,16 @@ def initialize_file_browser(self):
     @param.depends("show_browser", watch=True)
     def show_hide_browser(self):
         self.file_browser_container.visible = self.show_browser
-        self.param.browse_toggle.label = "Browse"
+        self.param.browse_toggle.label = "📂"
+        self.param.browse_toggle.doc = "Open file browser"
         if self.show_browser:
             self.initialize_file_browser()
-            self.param.browse_toggle.label = "Hide"
+            self.param.browse_toggle.label = "❌"
+            self.param.browse_toggle.doc = "Close file browser"
 
     def input_row(self):
         file_path = pn.widgets.TextInput.from_param(self.param.file_path, sizing_mode="stretch_width")
-        browse_toggle = pn.widgets.Button.from_param(
-            self.param.browse_toggle, button_type="primary", width=100, align="end"
-        )
+        browse_toggle = pn.widgets.Button.from_param(self.param.browse_toggle, width=40, align="end")
 
         browse_toggle.js_on_click(
             args={"btn": browse_toggle},

uit/gui_tools/submit.py

@@ -7,30 +7,65 @@
 import param
 import panel as pn
 
-from .file_browser import HpcFileBrowser, get_js_loading_code
+from .file_browser import HpcFileBrowser, create_file_browser, get_js_loading_code, FileSelector
 from .utils import HpcBase, HpcConfigurable
 from ..uit import QUEUES
 from ..pbs_script import NODE_TYPES, factors, PbsScript
 from ..job import PbsJob
 
+
 logger = logging.getLogger(__name__)
 
 
 class PbsScriptInputs(HpcBase):
-    hpc_subproject = param.Selector(default=None, label="HPC Subproject", precedence=3)
-    subproject_usage = param.DataFrame(precedence=3.1)
-    workdir = param.String(default="", precedence=4)
-    node_type = param.Selector(default="", objects=[], label="Node Type", precedence=5)
-    nodes = param.Integer(default=1, bounds=(1, 1000), precedence=5.1)
-    processes_per_node = param.Selector(default=1, objects=[], label="Processes per Node", precedence=5.2)
-    wall_time = param.String(default="01:00:00", label="Wall Time", precedence=6)
+    hpc_subproject = param.Selector(
+        default=None,
+        label="HPC Subproject",
+        precedence=3,
+        doc="The resource allocation code that will be used when submitting this job.",
+    )
+    subproject_usage = param.DataFrame(precedence=3.1, doc="Usage details about your available subproject allocations.")
+    node_type = param.Selector(
+        default="", objects=[], label="Node Type", precedence=5, doc="Type of node on which this job will be run."
+    )
+    nodes = param.Integer(
+        default=1,
+        bounds=(1, 1000),
+        precedence=5.1,
+        doc=(
+            "Number of nodes to request for the job.\n\n"
+            "**Note:** for array jobs, the number of nodes requested are available to each sub job."
+        ),
+    )
+    processes_per_node = param.Selector(
+        default=1,
+        objects=[],
+        label="Processes per Node",
+        precedence=5.2,
+        doc="Number of processes per node to request for the job.",
+    )
+    wall_time = param.String(
+        default="01:00:00",
+        label="Wall Time (HH:MM:SS)",
+        precedence=6,
+        doc=(
+            "Maximum allowable time for the job to run.\n\n"
+            "**Note:** for array jobs, the entire amount of wall time requested is available to each sub job."
+        ),
+    )
     wall_time_alert = pn.pane.Alert(visible=False)
     node_alert = pn.pane.Alert(visible=False)
-    queue = param.Selector(default=QUEUES[0], objects=QUEUES, precedence=7)
+    queue = param.Selector(
+        default=QUEUES[0], objects=QUEUES, precedence=7, doc="Scheduling queue to which the job will be submitted."
+    )
     max_wall_time = param.String(default="Not Found", label="Max Wall Time", precedence=7.1)
     max_nodes = param.String(default="Not Found", label="Max Processes", precedence=7.2)
     submit_script_filename = param.String(default="run.pbs", precedence=8)
-    notification_email = param.String(label="Notification E-mail(s)", precedence=9)
+    notification_email = param.String(
+        label="Notification E-mail(s)",
+        precedence=9,
+        doc="E-mail address to receive notification(s) when the job starts and/or ends.",
+    )
     notify_start = param.Boolean(default=True, label="when job begins", precedence=9.1)
     notify_end = param.Boolean(default=True, label="when job ends", precedence=9.2)
 
@@ -39,6 +74,22 @@ class PbsScriptInputs(HpcBase):
     wall_time_maxes = None
     node_maxes = None
 
+    def __init__(self, **params):
+        super().__init__(**params)
+        self.workdir = FileSelector(
+            title="Base Directory",
+            show_browser=False,
+            help_text=(
+                "Base directory that the job's working directory path will be created in.\n\n"
+                "**Note:** by default the job's working directory is: "
+                f"`<BASE_DIRECTORY>/{PbsJob.DEFAULT_JOB_LABEL}/<JOB_NAME>.<TIMESTAMP>/`"
+            ),
+        )
+
+    @param.depends("uit_client", watch=True)
+    def set_file_browser(self):
+        self.workdir.file_browser = create_file_browser(self.uit_client, patterns=[])
+
     @staticmethod
     def get_default(value, objects):
         return value if value in objects else objects[0]
@@ -54,7 +105,7 @@ async def update_hpc_connection_dependent_defaults(self):
         subprojects = self.subproject_usage["Subproject"].to_list()
         self.param.hpc_subproject.objects = subprojects
         self.hpc_subproject = self.get_default(self.hpc_subproject, subprojects)
-        self.workdir = self.uit_client.WORKDIR.as_posix()
+        self.workdir.file_path = self.uit_client.WORKDIR.as_posix()
         self.param.node_type.objects = list(NODE_TYPES[self.uit_client.system].keys())
         self.node_type = self.get_default(self.node_type, self.param.node_type.objects)
         self.param.queue.objects = await self.await_if_async(self.uit_client.get_queues())
@@ -169,7 +220,7 @@ def pbs_options_view(self):
             ),
             pn.Column(
                 self.param.hpc_subproject,
-                self.param.workdir,
+                self.workdir,
                 self.param.node_type,
                 pn.widgets.Spinner.from_param(self.param.nodes),
                 self.param.processes_per_node,
@@ -198,39 +249,46 @@ class PbsScriptAdvancedInputs(HpcConfigurable):
     env_browsers = param.List()
     env_delete_buttons = param.List()
     file_browser = param.ClassSelector(class_=HpcFileBrowser)
-    file_browser_col = param.ClassSelector(class_=pn.Column, default=pn.Column(None, sizing_mode="stretch_width"))
+    file_browser_wb = param.ClassSelector(class_=pn.layout.WidgetBox)
     apply_file_browser = param.Action(label="Apply")
     close_file_browser = param.Action(lambda self: self.show_file_browser(False), label="Close")
     append_path = param.Boolean(label="Append to Path")
 
+    def __init__(self, **params):
+        super().__init__(**params)
+        self.environment_variables_card = pn.Card(
+            title="Environment Variables",
+            sizing_mode="stretch_width",
+            margin=(10, 0),
+        )
+        self.update_environment_variables_col()
+        self.file_browser_wb = pn.WidgetBox(
+            self.file_browser,
+            pn.Row(
+                pn.widgets.Checkbox.from_param(self.param.append_path, width=100),
+                pn.widgets.Button.from_param(
+                    self.param.apply_file_browser,
+                    button_type="success",
+                    width=100,
+                ),
+                pn.widgets.Button.from_param(
+                    self.param.close_file_browser,
+                    button_type="primary",
+                    width=100,
+                ),
+                align="end",
+            ),
+            sizing_mode="stretch_width",
+        )
+
     @param.depends("uit_client", watch=True)
     def configure_file_browser(self):
-        self.file_browser = None  # HpcFileBrowser(self.uit_client) #TODO
+        self.file_browser = create_file_browser(self.uit_client)
+        if self.file_browser_wb:
+            self.file_browser_wb[0] = self.file_browser
 
     def show_file_browser(self, show):
-        self.file_browser_col[0] = (
-            pn.WidgetBox(
-                self.file_browser.panel,
-                pn.Row(
-                    pn.widgets.Checkbox.from_param(self.param.append_path, width=100),
-                    pn.widgets.Button.from_param(
-                        self.param.apply_file_browser,
-                        button_type="success",
-                        width=100,
-                    ),
-                    pn.widgets.Button.from_param(
-                        self.param.close_file_browser,
-                        button_type="primary",
-                        width=100,
-                    ),
-                    align="end",
-                ),
-                sizing_mode="stretch_width",
-            )
-            if show
-            else None
-        )
-
+        self.environment_variables_card[-1] = self.file_browser_wb if show else None
         if not show:
             for btn in self.env_browsers:
                 btn.loading = False
@@ -281,8 +339,8 @@ def update_file_path(self, _, index):
         else:
             self.env_values[index].value = self.file_browser.value[0]
 
-    @param.depends("environment_variables")
-    def environment_variables_view(self):
+    @param.depends("environment_variables", watch=True)
+    def update_environment_variables_col(self):
         self.environment_variables.pop("", None)  # Clear blank key if there is one
         self.env_names = list()
         self.env_values = list()
@@ -311,25 +369,20 @@ def environment_variables_view(self):
         self.env_names[0].name = "Name"
         self.env_values[0].name = "Value"
 
-        return pn.Card(
-            *[
-                pn.Row(k, v, b, d, sizing_mode="stretch_width")
-                for k, v, b, d in zip_longest(
-                    self.env_names,
-                    self.env_values,
-                    self.env_browsers,
-                    self.env_delete_buttons,
-                )
-            ],
-            self.file_browser_col,
-            title="Environment Variables",
-            sizing_mode="stretch_width",
-            margin=(10, 0),
-        )
+        self.environment_variables_card[:] = [
+            pn.Row(k, v, b, d, sizing_mode="stretch_width")
+            for k, v, b, d in zip_longest(
+                self.env_names,
+                self.env_values,
+                self.env_browsers,
+                self.env_delete_buttons,
+            )
+        ]
+        self.environment_variables_card.append(None)
 
     def advanced_options_view(self):
         return pn.Column(
-            self.environment_variables_view,
+            self.environment_variables_card,
             pn.Card(
                 "<h3>Modules to Load</h3>",
                 pn.widgets.CrossSelector.from_param(self.param.modules_to_load, width=700),
@@ -463,11 +516,13 @@ def pbs_script(self):
 
     @property
     def job(self):
+
         if self._job is None:
             self._job = PbsJob(
                 script=self.pbs_script,
                 client=self.uit_client,
                 workspace=self.user_workspace,
+                base_dir=self.workdir.file_path,
             )
         return self._job
 

uit/gui_tools/utils.py

@@ -102,15 +102,13 @@ def load_config_file(self, reset=False):
 
 
 class HpcWorkspaces(HpcConfigurable):
-    working_dir = param.ClassSelector(class_=PurePosixPath)
+    base_dir = param.ClassSelector(class_=PurePosixPath)
+    remote_workspace_suffix = param.ClassSelector(class_=PurePosixPath)
     _user_workspace = param.ClassSelector(class_=Path)
 
     @property
-    def remote_workspace_suffix(self):
-        try:
-            return self.working_dir.relative_to(self.uit_client.WORKDIR)
-        except ValueError:
-            return self.working_dir.relative_to("/p")
+    def working_dir(self):
+        return self.base_dir / self.remote_workspace_suffix
 
     @property
     def workspace(self):
@@ -188,7 +186,8 @@ def update_selected_sub_job(self):
 
     def update_working_dir(self):
         if self.selected_job is not None:
-            self.working_dir = self.selected_job.working_dir
+            self.base_dir = self.selected_job.base_dir
+            self.remote_workspace_suffix = self.selected_job.remote_workspace_suffix
 
     @param.depends("selected_sub_job", watch=True)
     def update_active_job(self):